using json = basic_json<>;\nThis type is the default specialization of the basic_json class which uses the standard template types.
"},{"location":"api/json/#examples","title":"Examples","text":"ExampleThe example below demonstrates how to use the type nlohmann::json.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json j =\n {\n {\"pi\", 3.141},\n {\"happy\", true},\n {\"name\", \"Niels\"},\n {\"nothing\", nullptr},\n {\n \"answer\", {\n {\"everything\", 42}\n }\n },\n {\"list\", {1, 0, 2}},\n {\n \"object\", {\n {\"currency\", \"USD\"},\n {\"value\", 42.99}\n }\n }\n };\n\n // add new values\n j[\"new\"][\"key\"][\"value\"] = {\"another\", \"list\"};\n\n // count elements\n auto s = j.size();\n j[\"size\"] = s;\n\n // pretty print with indent of 4 spaces\n std::cout << std::setw(4) << j << '\\n';\n}\nOutput:
{\n \"answer\": {\n \"everything\": 42\n },\n \"happy\": true,\n \"list\": [\n 1,\n 0,\n 2\n ],\n \"name\": \"Niels\",\n \"new\": {\n \"key\": {\n \"value\": [\n \"another\",\n \"list\"\n ]\n }\n },\n \"nothing\": null,\n \"object\": {\n \"currency\": \"USD\",\n \"value\": 42.99\n },\n \"pi\": 3.141,\n \"size\": 8\n}\nSince version 1.0.0.
"},{"location":"api/operator_gtgt/","title":"nlohmann::operator>>(basic_json)","text":"std::istream& operator>>(std::istream& i, basic_json& j);\nDeserializes an input stream to a JSON value.
"},{"location":"api/operator_gtgt/#parameters","title":"Parameters","text":"i (in, out) input stream to read a serialized JSON value from j (in, out) JSON value to write the deserialized input to"},{"location":"api/operator_gtgt/#return-value","title":"Return value","text":"the stream i
parse_error.101 in case of an unexpected token.Linear in the length of the input. The parser is a predictive LL(1) parser.
"},{"location":"api/operator_gtgt/#notes","title":"Notes","text":"A UTF-8 byte order mark is silently ignored.
Invalid Unicode escapes and unpaired surrogates in the input are reported as parse_error.101 with a detailed message.
Deprecation
This function replaces function std::istream& operator<<(basic_json& j, std::istream& i) which has been deprecated in version 3.0.0. It will be removed in version 4.0.0. Please replace calls like j << i; with i >> j;.
The example below shows how a JSON value is constructed by reading a serialization from a stream.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create stream with serialized JSON\n std::stringstream ss;\n ss << R\"({\n \"number\": 23,\n \"string\": \"Hello, world!\",\n \"array\": [1, 2, 3, 4, 5],\n \"boolean\": false,\n \"null\": null\n })\";\n\n // create JSON value and read the serialization from the stream\n json j;\n ss >> j;\n\n // serialize JSON\n std::cout << std::setw(2) << j << '\\n';\n}\nOutput:
{\n \"array\": [\n 1,\n 2,\n 3,\n 4,\n 5\n ],\n \"boolean\": false,\n \"null\": null,\n \"number\": 23,\n \"string\": \"Hello, world!\"\n}\njson operator \"\"_json(const char* s, std::size_t n);\njson operator \"\"_json(const char8_t* s, std::size_t n); // since C++20\nThis 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.
It is recommended to bring the operator into scope using any of the following lines:
using nlohmann::literals::operator \"\"_json;\nusing namespace nlohmann::literals;\nusing namespace nlohmann::json_literals;\nusing namespace nlohmann::literals::json_literals;\nusing namespace nlohmann;\nThis is suggested to ease migration to the next major version release of the library. See JSON_USE_GLOBAL_UDLS for details.
s (in) a string representation of a JSON object n (in) length of string s"},{"location":"api/operator_literal_json/#return-value","title":"Return value","text":"json value parsed from s
The function can throw anything that parse(s, s+n) would throw.
Linear.
"},{"location":"api/operator_literal_json/#examples","title":"Examples","text":"ExampleThe following code shows how to create JSON values from string literals.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n json j = R\"( {\"hello\": \"world\", \"answer\": 42} )\"_json;\n\n std::cout << std::setw(2) << j << '\\n';\n}\nOutput:
{\n \"answer\": 42,\n \"hello\": \"world\"\n}\nnlohmann::literals::json_literals in 3.11.0.char8_t* overload in 3.12.x.json_pointer operator \"\"_json_pointer(const char* s, std::size_t n);\njson_pointer operator \"\"_json_pointer(const char8_t* s, std::size_t n); // since C++20\nThis 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.
It is recommended to bring the operator into scope using any of the following lines:
using nlohmann::literals::operator \"\"_json_pointer;\nusing namespace nlohmann::literals;\nusing namespace nlohmann::json_literals;\nusing namespace nlohmann::literals::json_literals;\nusing namespace nlohmann;\nJSON_USE_GLOBAL_UDLS for details."},{"location":"api/operator_literal_json_pointer/#parameters","title":"Parameters","text":"s (in) a string representation of a JSON Pointer n (in) length of string s"},{"location":"api/operator_literal_json_pointer/#return-value","title":"Return value","text":"json_pointer value parsed from s
The function can throw anything that json_pointer::json_pointer would throw.
Linear.
"},{"location":"api/operator_literal_json_pointer/#examples","title":"Examples","text":"ExampleThe following code shows how to create JSON Pointers from string literals.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n json j = R\"( {\"hello\": \"world\", \"answer\": 42} )\"_json;\n auto val = j[\"/hello\"_json_pointer];\n\n std::cout << std::setw(2) << val << '\\n';\n}\nOutput:
\"world\"\nnlohmann::literals::json_literals in 3.11.0.char8_t* overload in 3.12.x.std::ostream& operator<<(std::ostream& o, const basic_json& j); // (1)\n\nstd::ostream& operator<<(std::ostream& o, const json_pointer& ptr); // (2)\nj to the output stream o. The JSON value will be serialized using the dump member function.width of the output stream o. For instance, using the manipulator std::setw(4) on o sets the indentation level to 4 and the serialization result is the same as calling dump(4).fill of the output stream o. For instance, the manipulator std::setfill('\\\\t') sets indentation to use a tab character rather than the default space character.ptr to the output stream o. The string representation is obtained using the to_string member function.o (in, out) stream to write to j (in) JSON value to serialize ptr (in) JSON pointer to write"},{"location":"api/operator_ltlt/#return-value","title":"Return value","text":"the stream o
type_error.316 if a string stored inside the JSON value is not UTF-8 encoded. Note that unlike the dump member functions, no error_handler can be set.Linear.
"},{"location":"api/operator_ltlt/#notes","title":"Notes","text":"Deprecation
Function std::ostream& operator<<(std::ostream& o, const basic_json& j) replaces function std::ostream& operator>>(const basic_json& j, std::ostream& o) which has been deprecated in version 3.0.0. It will be removed in version 4.0.0. Please replace calls like j >> o; with o << j;.
The example below shows the serialization with different parameters to width to adjust the indentation level.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n\n // serialize without indentation\n std::cout << j_object << \"\\n\\n\";\n std::cout << j_array << \"\\n\\n\";\n\n // serialize with indentation\n std::cout << std::setw(4) << j_object << \"\\n\\n\";\n std::cout << std::setw(2) << j_array << \"\\n\\n\";\n std::cout << std::setw(1) << std::setfill('\\t') << j_object << \"\\n\\n\";\n}\nOutput:
{\"one\":1,\"two\":2}\n\n[1,2,4,8,16]\n\n{\n \"one\": 1,\n \"two\": 2\n}\n\n[\n 1,\n 2,\n 4,\n 8,\n 16\n]\n\n{\n \"one\": 1,\n \"two\": 2\n}\nThe example below shows how to write a JSON pointer to a stream.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON pointer\n json::json_pointer ptr(\"/foo/bar/baz\");\n\n // write string representation to stream\n std::cout << ptr << std::endl;\n}\nOutput:
/foo/bar/baz\nstd::ostream& operator>>(const basic_json& j, std::ostream& o) in version 3.0.0.using ordered_json = basic_json<ordered_map>;\nThis type preserves the insertion order of object keys.
"},{"location":"api/ordered_json/#iterator-invalidation","title":"Iterator invalidation","text":"The type is based on ordered_map which in turn uses a std::vector to store object elements. Therefore, adding object elements can yield a reallocation in which case all iterators (including the end() iterator) and all references to the elements are invalidated. Also, any iterator or reference after the insertion point will point to the same index, which is now a different value.
The example below demonstrates how ordered_json preserves the insertion order of object keys.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing ordered_json = nlohmann::ordered_json;\n\nint main()\n{\n ordered_json j;\n j[\"one\"] = 1;\n j[\"two\"] = 2;\n j[\"three\"] = 3;\n\n std::cout << j.dump(2) << '\\n';\n}\nOutput:
{\n \"one\": 1,\n \"two\": 2,\n \"three\": 3\n}\nSince version 3.9.0.
"},{"location":"api/ordered_map/","title":"nlohmann::ordered_map","text":"template<class Key, class T, class IgnoredLess = std::less<Key>,\n class Allocator = std::allocator<std::pair<const Key, T>>>\nstruct ordered_map : std::vector<std::pair<const Key, T>, Allocator>;\nA minimal map-like container that preserves insertion order for use within nlohmann::ordered_json (nlohmann::basic_json<ordered_map>).
Key key type T mapped type IgnoredLess comparison function (ignored and only added to ensure compatibility with std::map) Allocator allocator type"},{"location":"api/ordered_map/#iterator-invalidation","title":"Iterator invalidation","text":"The type uses a std::vector to store object elements. Therefore, adding elements can yield a reallocation in which case all iterators (including the end() iterator) and all references to the elements are invalidated.
Key)T)std::vector<std::pair<const Key, T>, Allocator>)std::equal_to<Key> // until C++14\n\nstd::equal_to<> // since C++14\nThe example shows the different behavior of std::map and nlohmann::ordered_map.
#include <iostream>\n#include <nlohmann/json.hpp>\n\n// simple output function\ntemplate<typename Map>\nvoid output(const char* prefix, const Map& m)\n{\n std::cout << prefix << \" = { \";\n for (auto& element : m)\n {\n std::cout << element.first << \":\" << element.second << ' ';\n }\n std::cout << \"}\" << std::endl;\n}\n\nint main()\n{\n // create and fill two maps\n nlohmann::ordered_map<std::string, std::string> m_ordered;\n m_ordered[\"one\"] = \"eins\";\n m_ordered[\"two\"] = \"zwei\";\n m_ordered[\"three\"] = \"drei\";\n\n std::map<std::string, std::string> m_std;\n m_std[\"one\"] = \"eins\";\n m_std[\"two\"] = \"zwei\";\n m_std[\"three\"] = \"drei\";\n\n // output: m_ordered is ordered by insertion order, m_std is ordered by key\n output(\"m_ordered\", m_ordered);\n output(\"m_std\", m_std);\n\n // erase and re-add \"one\" key\n m_ordered.erase(\"one\");\n m_ordered[\"one\"] = \"eins\";\n\n m_std.erase(\"one\");\n m_std[\"one\"] = \"eins\";\n\n // output: m_ordered shows newly added key at the end; m_std is again ordered by key\n output(\"m_ordered\", m_ordered);\n output(\"m_std\", m_std);\n}\nOutput:
m_ordered = { one:eins two:zwei three:drei }\nm_std = { one:eins three:drei two:zwei }\nm_ordered = { two:zwei three:drei one:eins }\nm_std = { one:eins three:drei two:zwei }\nnlohmann::ordered_json.template<typename, typename>\nstruct adl_serializer;\nSerializer that uses ADL (Argument-Dependent Lookup) to choose to_json/from_json functions from the types' namespaces.
It is implemented similarly to
template<typename ValueType>\nstruct adl_serializer {\n template<typename BasicJsonType>\n static void to_json(BasicJsonType& j, const T& value) {\n // calls the \"to_json\" method in T's namespace\n }\n\n template<typename BasicJsonType>\n static void from_json(const BasicJsonType& j, T& value) {\n // same thing, but with the \"from_json\" method\n }\n};\n// (1)\ntemplate<typename BasicJsonType, typename TargetType = ValueType>\nstatic auto from_json(BasicJsonType && j, TargetType& val) noexcept(\n noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))\n-> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())\n\n// (2)\ntemplate<typename BasicJsonType, typename TargetType = ValueType>\nstatic auto from_json(BasicJsonType && j) noexcept(\nnoexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))\n-> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))\nThis function is usually called by the get() function of the basic_json class (either explicitly or via the conversion operators).
j (in) JSON value to read from val (out) value to write to"},{"location":"api/adl_serializer/from_json/#return-value","title":"Return value","text":"val.j converted to TargetTypeThe example below shows how a from_json function can be implemented for a user-defined type. This function is called by the adl_serializer when get<ns::person>() is called.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\n// a simple struct to model a person\nstruct person\n{\n std::string name;\n std::string address;\n int age;\n};\n} // namespace ns\n\nnamespace ns\n{\nvoid from_json(const json& j, person& p)\n{\n j.at(\"name\").get_to(p.name);\n j.at(\"address\").get_to(p.address);\n j.at(\"age\").get_to(p.age);\n}\n} // namespace ns\n\nint main()\n{\n json j;\n j[\"name\"] = \"Ned Flanders\";\n j[\"address\"] = \"744 Evergreen Terrace\";\n j[\"age\"] = 60;\n\n auto p = j.get<ns::person>();\n\n std::cout << p.name << \" (\" << p.age << \") lives in \" << p.address << std::endl;\n}\nOutput:
Ned Flanders (60) lives in 744 Evergreen Terrace\nThe example below shows how a from_json is implemented as part of a specialization of the adl_serializer to realize the conversion of a non-default-constructible type.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\n// a simple struct to model a person (not default constructible)\nstruct person\n{\n person(std::string n, std::string a, int aa)\n : name(std::move(n)), address(std::move(a)), age(aa)\n {}\n\n std::string name;\n std::string address;\n int age;\n};\n} // namespace ns\n\nnamespace nlohmann\n{\ntemplate <>\nstruct adl_serializer<ns::person>\n{\n static ns::person from_json(const json& j)\n {\n return {j.at(\"name\"), j.at(\"address\"), j.at(\"age\")};\n }\n\n // Here's the catch! You must provide a to_json method! Otherwise, you\n // will not be able to convert person to json, since you fully\n // specialized adl_serializer on that type\n static void to_json(json& j, ns::person p)\n {\n j[\"name\"] = p.name;\n j[\"address\"] = p.address;\n j[\"age\"] = p.age;\n }\n};\n} // namespace nlohmann\n\nint main()\n{\n json j;\n j[\"name\"] = \"Ned Flanders\";\n j[\"address\"] = \"744 Evergreen Terrace\";\n j[\"age\"] = 60;\n\n auto p = j.get<ns::person>();\n\n std::cout << p.name << \" (\" << p.age << \") lives in \" << p.address << std::endl;\n}\nOutput:
Ned Flanders (60) lives in 744 Evergreen Terrace\ntemplate<typename BasicJsonType, typename TargetType = ValueType>\nstatic auto to_json(BasicJsonType& j, TargetType && val) noexcept(\n noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))\n-> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())\nThis function is usually called by the constructors of the basic_json class.
"},{"location":"api/adl_serializer/to_json/#parameters","title":"Parameters","text":"j (out) JSON value to write to val (in) value to read from"},{"location":"api/adl_serializer/to_json/#examples","title":"Examples","text":"Example The example below shows how a to_json function can be implemented for a user-defined type. This function is called by the adl_serializer when the constructor basic_json(ns::person) is called.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\n// a simple struct to model a person\nstruct person\n{\n std::string name;\n std::string address;\n int age;\n};\n} // namespace ns\n\nnamespace ns\n{\nvoid to_json(json& j, const person& p)\n{\n j = json{ {\"name\", p.name}, {\"address\", p.address}, {\"age\", p.age} };\n}\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n json j = p;\n\n std::cout << j << std::endl;\n}\nOutput:
{\"address\":\"744 Evergreen Terrace\",\"age\":60,\"name\":\"Ned Flanders\"}\nDefined in header <nlohmann/json.hpp>
template<\n template<typename U, typename V, typename... Args> class ObjectType = std::map,\n template<typename U, typename... Args> class ArrayType = std::vector,\n class StringType = std::string,\n class BooleanType = bool,\n class NumberIntegerType = std::int64_t,\n class NumberUnsignedType = std::uint64_t,\n class NumberFloatType = double,\n template<typename U> class AllocatorType = std::allocator,\n template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer,\n class BinaryType = std::vector<std::uint8_t>,\n class CustomBaseClass = void\n>\nclass basic_json;\nObjectType type for JSON objects object_t ArrayType type for JSON arrays array_t StringType type for JSON strings and object keys string_t BooleanType type for JSON booleans boolean_t NumberIntegerType type for JSON integer numbers number_integer_t NumberUnsignedType type for JSON unsigned integer numbers number_unsigned_t NumberFloatType type for JSON floating-point numbers number_float_t AllocatorType type of the allocator to use JSONSerializer the serializer to resolve internal calls to to_json() and from_json() json_serializer BinaryType type for binary arrays binary_t CustomBaseClass extension point for user code json_base_class_t"},{"location":"api/basic_json/#specializations","title":"Specializations","text":"All operations that add values to an array (push_back , operator+=, emplace_back, insert, and operator[] for a non-existing index) can yield a reallocation, in which case all iterators (including the end() iterator) and all references to the elements are invalidated.
For ordered_json, also all operations that add a value to an object (push_back, operator+=, emplace, insert, update, and operator[] for a non-existing key) can yield a reallocation, in which case all iterators (including the end() iterator) and all references to the elements are invalidated.
The class satisfies the following concept requirements:
"},{"location":"api/basic_json/#basic","title":"Basic","text":"==, see operator==.<, see operator<.swap.std::nullptr_t objects which are used to model the null value.basic_json valuesbasic_json classvalue_type basic_json reference value_type& const_reference const value_type& difference_type std::ptrdiff_t size_type std::size_t allocator_type AllocatorType<basic_json> pointer std::allocator_traits<allocator_type>::pointer const_pointer std::allocator_traits<allocator_type>::const_pointer iterator LegacyBidirectionalIterator const_iterator constant LegacyBidirectionalIterator reverse_iterator reverse iterator, derived from iterator const_reverse_iterator reverse iterator, derived from const_iterator iteration_proxy helper type for items function"},{"location":"api/basic_json/#json-value-data-types","title":"JSON value data types","text":"Functions to inspect the type of a JSON value.
Optional functions to access the diagnostic positions.
Direct access to the stored value of a JSON value.
Access to the JSON value
to_string function for JSON valuesformat_as function for JSON values (fmt support)std::formatThe example shows how the library is used.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json j =\n {\n {\"pi\", 3.141},\n {\"happy\", true},\n {\"name\", \"Niels\"},\n {\"nothing\", nullptr},\n {\n \"answer\", {\n {\"everything\", 42}\n }\n },\n {\"list\", {1, 0, 2}},\n {\n \"object\", {\n {\"currency\", \"USD\"},\n {\"value\", 42.99}\n }\n }\n };\n\n // add new values\n j[\"new\"][\"key\"][\"value\"] = {\"another\", \"list\"};\n\n // count elements\n auto s = j.size();\n j[\"size\"] = s;\n\n // pretty print with indent of 4 spaces\n std::cout << std::setw(4) << j << '\\n';\n}\nOutput:
{\n \"answer\": {\n \"everything\": 42\n },\n \"happy\": true,\n \"list\": [\n 1,\n 0,\n 2\n ],\n \"name\": \"Niels\",\n \"new\": {\n \"key\": {\n \"value\": [\n \"another\",\n \"list\"\n ]\n }\n },\n \"nothing\": null,\n \"object\": {\n \"currency\": \"USD\",\n \"value\": 42.99\n },\n \"pi\": 3.141,\n \"size\": 8\n}\n// (1)\ntemplate<typename InputType>\nstatic bool accept(InputType&& i,\n const bool ignore_comments = false,\n const bool ignore_trailing_commas = false);\n\n// (2)\ntemplate<typename IteratorType>\nstatic bool accept(IteratorType first, IteratorType last,\n const bool ignore_comments = false,\n const bool ignore_trailing_commas = false);\nChecks whether the input is valid JSON.
Reads from a pair of character iterators
The value_type of the iterator must be an integral type with a size of 1, 2, or 4 bytes, which will be interpreted respectively as UTF-8, UTF-16, and UTF-32.
Unlike the parse() function, this function neither throws an exception in case of invalid JSON input (i.e., a parse error) nor creates diagnostic information.
InputType A compatible input, for instance:
std::istream objectFILE pointer (throws if null)std::stringobj for which begin(obj) and end(obj) produces a valid pair of iterators.IteratorType a compatible iterator type, for instance.
std::string::iterator or std::vector<std::uint8_t>::iteratorptr and ptr + leni (in) Input to parse from. ignore_comments (in) whether comments should be ignored and treated like whitespace (true) or yield a parse error (false); (optional, false by default) ignore_trailing_commas (in) whether trailing commas in arrays or objects should be ignored and treated like whitespace (true) or yield a parse error (false); (optional, false by default) first (in) iterator to the start of the character range last (in) iterator to the end of the character range"},{"location":"api/basic_json/accept/#return-value","title":"Return value","text":"Whether the input is valid JSON.
"},{"location":"api/basic_json/accept/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/accept/#exceptions","title":"Exceptions","text":"Throws parse_error.101 in case of an empty input like a null FILE* or char* pointer.
Linear in the length of the input. The parser is a predictive LL(1) parser.
"},{"location":"api/basic_json/accept/#notes","title":"Notes","text":"A UTF-8 byte order mark is silently ignored.
"},{"location":"api/basic_json/accept/#examples","title":"Examples","text":"ExampleThe example below demonstrates the accept() function reading from a string.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a valid JSON text\n auto valid_text = R\"(\n {\n \"numbers\": [1, 2, 3]\n }\n )\";\n\n // an invalid JSON text\n auto invalid_text = R\"(\n {\n \"strings\": [\"extra\", \"comma\", ]\n }\n )\";\n\n std::cout << std::boolalpha\n << json::accept(valid_text) << ' '\n << json::accept(invalid_text) << '\\n';\n}\nOutput:
true false\nignore_comments added in version 3.9.0.FILE* null pointers to exception in version 3.12.0.ignore_trailing_commas in version 3.12.x.Deprecation
Overload (2) replaces calls to accept with a pair of iterators as their first parameter which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like accept({ptr, ptr+len}, ...); with accept(ptr, ptr+len, ...);.
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
static basic_json array(initializer_list_t init = {});\nCreates a JSON array value from a given initializer list. That is, given a list of values a, b, c, creates the JSON value [a, b, c]. If the initializer list is empty, the empty array [] is created.
init (in) initializer list with JSON values to create an array from (optional)"},{"location":"api/basic_json/array/#return-value","title":"Return value","text":"JSON array value
"},{"location":"api/basic_json/array/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/array/#complexity","title":"Complexity","text":"Linear in the size of init.
This function is only needed to express two edge cases that cannot be realized with the initializer list constructor (basic_json(initializer_list_t, bool, value_t)). These cases are:
The following code shows an example for the array function.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON arrays\n json j_no_init_list = json::array();\n json j_empty_init_list = json::array({});\n json j_nonempty_init_list = json::array({1, 2, 3, 4});\n json j_list_of_pairs = json::array({ {\"one\", 1}, {\"two\", 2} });\n\n // serialize the JSON arrays\n std::cout << j_no_init_list << '\\n';\n std::cout << j_empty_init_list << '\\n';\n std::cout << j_nonempty_init_list << '\\n';\n std::cout << j_list_of_pairs << '\\n';\n}\nOutput:
[]\n[]\n[1,2,3,4]\n[[\"one\",1],[\"two\",2]]\nbasic_json(initializer_list_t) - create a JSON value from an initializer listobject - create a JSON object value from an initializer listusing array_t = ArrayType<basic_json, AllocatorType<basic_json>>;\nThe type used to store JSON arrays.
RFC 8259 describes JSON arrays as follows:
An array is an ordered sequence of zero or more values.
To store objects in C++, a type is defined by the template parameters explained below.
"},{"location":"api/basic_json/array_t/#template-parameters","title":"Template parameters","text":"ArrayType container type to store arrays (e.g., std::vector or std::list) AllocatorType the allocator to use for objects (e.g., std::allocator)"},{"location":"api/basic_json/array_t/#notes","title":"Notes","text":""},{"location":"api/basic_json/array_t/#default-type","title":"Default type","text":"With the default values for ArrayType (std::vector) and AllocatorType (std::allocator), the default value for array_t is:
std::vector<\n basic_json, // value_type\n std::allocator<basic_json> // allocator_type\n>\nRFC 8259 specifies:
An implementation may set limits on the maximum depth of nesting.
In this class, the array's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON array.
Arrays are stored as pointers in a basic_json type. That is, for any access to array values, a pointer of type array_t* must be dereferenced.
The following code shows that array_t is by default, a typedef to std::vector<nlohmann::json>.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha << std::is_same<std::vector<json>, json::array_t>::value << std::endl;\n}\nOutput:
true\n// (1)\nreference at(size_type idx);\nconst_reference at(size_type idx) const;\n\n// (2)\nreference at(const typename object_t::key_type& key);\nconst_reference at(const typename object_t::key_type& key) const;\n\n// (3)\ntemplate<typename KeyType>\nreference at(KeyType&& key);\ntemplate<typename KeyType>\nconst_reference at(KeyType&& key) const;\n\n// (4)\nreference at(const json_pointer& ptr);\nconst_reference at(const json_pointer& ptr) const;\nidx, with bounds checking.key, with bounds checking.KeyType is comparable with typename object_t::key_type and typename object_comparator_t::is_transparent denotes a type.ptr, with bounds checking.KeyType A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17)."},{"location":"api/basic_json/at/#parameters","title":"Parameters","text":"idx (in) index of the element to access key (in) object key of the elements to access ptr (in) JSON pointer to the desired element"},{"location":"api/basic_json/at/#return-value","title":"Return value","text":"idxkeykeyptrStrong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/at/#exceptions","title":"Exceptions","text":"type_error.304 if the JSON value is not an array; in this case, calling at with an index makes no sense. See the example below.out_of_range.401 if the index idx is out of range of the array; that is, idx >= size(). See the example below.type_error.304 if the JSON value is not an object; in this case, calling at with a key makes no sense. See the example below.out_of_range.403 if the key key is not stored in the object; that is, find(key) == end(). See the example below.parse_error.106 if an array index in the passed JSON pointer ptr begins with '0'. See the example below.parse_error.109 if an array index in the passed JSON pointer ptr is not a number. See the example below.out_of_range.401 if an array index in the passed JSON pointer ptr is out of range. See the example below.out_of_range.402 if the array index '-' is used in the passed JSON pointer ptr. As at provides checked access (and no elements are implicitly inserted), the index '-' is always invalid. See the example below.out_of_range.403 if the JSON pointer describes a key of an object which cannot be found. See the example below.out_of_range.404 if the JSON pointer ptr can not be resolved. See the example below.out_of_range.410 if an array index in the passed JSON pointer ptr exceeds the range of size_type (e.g., on 32-bit platforms).The example below shows how array elements can be read and written using at(). It also demonstrates the different exceptions that can be thrown.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON array\n json array = {\"first\", \"2nd\", \"third\", \"fourth\"};\n\n // output element at index 2 (third element)\n std::cout << array.at(2) << '\\n';\n\n // change element at index 1 (second element) to \"second\"\n array.at(1) = \"second\";\n\n // output changed array\n std::cout << array << '\\n';\n\n // exception type_error.304\n try\n {\n // use at() on a non-array type\n json str = \"I am a string\";\n str.at(0) = \"Another string\";\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // exception out_of_range.401\n try\n {\n // try to write beyond the array limit\n array.at(5) = \"sixth\";\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
\"third\"\n[\"first\",\"second\",\"third\",\"fourth\"]\n[json.exception.type_error.304] cannot use at() with string\n[json.exception.out_of_range.401] array index 5 is out of range\nThe example below shows how array elements can be read using at(). It also demonstrates the different exceptions that can be thrown.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON array\n const json array = {\"first\", \"2nd\", \"third\", \"fourth\"};\n\n // output element at index 2 (third element)\n std::cout << array.at(2) << '\\n';\n\n // exception type_error.304\n try\n {\n // use at() on a non-array type\n const json str = \"I am a string\";\n std::cout << str.at(0) << '\\n';\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // exception out_of_range.401\n try\n {\n // try to read beyond the array limit\n std::cout << array.at(5) << '\\n';\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
\"third\"\n[json.exception.type_error.304] cannot use at() with string\n[json.exception.out_of_range.401] array index 5 is out of range\nThe example below shows how object elements can be read and written using at(). It also demonstrates the different exceptions that can be thrown.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON object\n json object =\n {\n {\"the good\", \"il buono\"},\n {\"the bad\", \"il cattivo\"},\n {\"the ugly\", \"il brutto\"}\n };\n\n // output element with key \"the ugly\"\n std::cout << object.at(\"the ugly\") << '\\n';\n\n // change element with key \"the bad\"\n object.at(\"the bad\") = \"il cattivo\";\n\n // output changed array\n std::cout << object << '\\n';\n\n // exception type_error.304\n try\n {\n // use at() on a non-object type\n json str = \"I am a string\";\n str.at(\"the good\") = \"Another string\";\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // exception out_of_range.401\n try\n {\n // try to write at a nonexisting key\n object.at(\"the fast\") = \"il rapido\";\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
\"il brutto\"\n{\"the bad\":\"il cattivo\",\"the good\":\"il buono\",\"the ugly\":\"il brutto\"}\n[json.exception.type_error.304] cannot use at() with string\n[json.exception.out_of_range.403] key 'the fast' not found\nThe example below shows how object elements can be read using at(). It also demonstrates the different exceptions that can be thrown.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON object\n const json object =\n {\n {\"the good\", \"il buono\"},\n {\"the bad\", \"il cattivo\"},\n {\"the ugly\", \"il brutto\"}\n };\n\n // output element with key \"the ugly\"\n std::cout << object.at(\"the ugly\") << '\\n';\n\n // exception type_error.304\n try\n {\n // use at() on a non-object type\n const json str = \"I am a string\";\n std::cout << str.at(\"the good\") << '\\n';\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // exception out_of_range.401\n try\n {\n // try to read from a nonexisting key\n std::cout << object.at(\"the fast\") << '\\n';\n }\n catch (const json::out_of_range)\n {\n std::cout << \"out of range\" << '\\n';\n }\n}\nOutput:
\"il brutto\"\n[json.exception.type_error.304] cannot use at() with string\nout of range\nThe example below shows how object elements can be read and written using at(). It also demonstrates the different exceptions that can be thrown.
#include <iostream>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON object\n json object =\n {\n {\"the good\", \"il buono\"},\n {\"the bad\", \"il cattivo\"},\n {\"the ugly\", \"il brutto\"}\n };\n\n // output element with key \"the ugly\" using string_view\n std::cout << object.at(\"the ugly\"sv) << '\\n';\n\n // change element with key \"the bad\" using string_view\n object.at(\"the bad\"sv) = \"il cattivo\";\n\n // output changed array\n std::cout << object << '\\n';\n\n // exception type_error.304\n try\n {\n // use at() with string_view on a non-object type\n json str = \"I am a string\";\n str.at(\"the good\"sv) = \"Another string\";\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // exception out_of_range.401\n try\n {\n // try to write at a nonexisting key using string_view\n object.at(\"the fast\"sv) = \"il rapido\";\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
\"il brutto\"\n{\"the bad\":\"il cattivo\",\"the good\":\"il buono\",\"the ugly\":\"il brutto\"}\n[json.exception.type_error.304] cannot use at() with string\n[json.exception.out_of_range.403] key 'the fast' not found\nThe example below shows how object elements can be read using at(). It also demonstrates the different exceptions that can be thrown.
#include <iostream>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON object\n const json object =\n {\n {\"the good\", \"il buono\"},\n {\"the bad\", \"il cattivo\"},\n {\"the ugly\", \"il brutto\"}\n };\n\n // output element with key \"the ugly\" using string_view\n std::cout << object.at(\"the ugly\"sv) << '\\n';\n\n // exception type_error.304\n try\n {\n // use at() with string_view on a non-object type\n const json str = \"I am a string\";\n std::cout << str.at(\"the good\"sv) << '\\n';\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // exception out_of_range.401\n try\n {\n // try to read from a nonexisting key using string_view\n std::cout << object.at(\"the fast\"sv) << '\\n';\n }\n catch (const json::out_of_range& e)\n {\n std::cout << \"out of range\" << '\\n';\n }\n}\nOutput:
\"il brutto\"\n[json.exception.type_error.304] cannot use at() with string\nout of range\nThe example below shows how object elements can be read and written using at(). It also demonstrates the different exceptions that can be thrown.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j =\n {\n {\"number\", 1}, {\"string\", \"foo\"}, {\"array\", {1, 2}}\n };\n\n // read-only access\n\n // output element with JSON pointer \"/number\"\n std::cout << j.at(\"/number\"_json_pointer) << '\\n';\n // output element with JSON pointer \"/string\"\n std::cout << j.at(\"/string\"_json_pointer) << '\\n';\n // output element with JSON pointer \"/array\"\n std::cout << j.at(\"/array\"_json_pointer) << '\\n';\n // output element with JSON pointer \"/array/1\"\n std::cout << j.at(\"/array/1\"_json_pointer) << '\\n';\n\n // writing access\n\n // change the string\n j.at(\"/string\"_json_pointer) = \"bar\";\n // output the changed string\n std::cout << j[\"string\"] << '\\n';\n\n // change an array element\n j.at(\"/array/1\"_json_pointer) = 21;\n // output the changed array\n std::cout << j[\"array\"] << '\\n';\n\n // out_of_range.106\n try\n {\n // try to use an array index with leading '0'\n json::reference ref = j.at(\"/array/01\"_json_pointer);\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.109\n try\n {\n // try to use an array index that is not a number\n json::reference ref = j.at(\"/array/one\"_json_pointer);\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.401\n try\n {\n // try to use an invalid array index\n json::reference ref = j.at(\"/array/4\"_json_pointer);\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.402\n try\n {\n // try to use the array index '-'\n json::reference ref = j.at(\"/array/-\"_json_pointer);\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.403\n try\n {\n // try to use a JSON pointer to a nonexistent object key\n json::const_reference ref = j.at(\"/foo\"_json_pointer);\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.404\n try\n {\n // try to use a JSON pointer that cannot be resolved\n json::reference ref = j.at(\"/number/foo\"_json_pointer);\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
1\n\"foo\"\n[1,2]\n2\n\"bar\"\n[1,21]\n[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'\n[json.exception.parse_error.109] parse error: array index 'one' is not a number\n[json.exception.out_of_range.401] array index 4 is out of range\n[json.exception.out_of_range.402] array index '-' (2) is out of range\n[json.exception.out_of_range.403] key 'foo' not found\n[json.exception.out_of_range.404] unresolved reference token 'foo'\nThe example below shows how object elements can be read using at(). It also demonstrates the different exceptions that can be thrown.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n const json j =\n {\n {\"number\", 1}, {\"string\", \"foo\"}, {\"array\", {1, 2}}\n };\n\n // read-only access\n\n // output element with JSON pointer \"/number\"\n std::cout << j.at(\"/number\"_json_pointer) << '\\n';\n // output element with JSON pointer \"/string\"\n std::cout << j.at(\"/string\"_json_pointer) << '\\n';\n // output element with JSON pointer \"/array\"\n std::cout << j.at(\"/array\"_json_pointer) << '\\n';\n // output element with JSON pointer \"/array/1\"\n std::cout << j.at(\"/array/1\"_json_pointer) << '\\n';\n\n // out_of_range.109\n try\n {\n // try to use an array index that is not a number\n json::const_reference ref = j.at(\"/array/one\"_json_pointer);\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.401\n try\n {\n // try to use an invalid array index\n json::const_reference ref = j.at(\"/array/4\"_json_pointer);\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.402\n try\n {\n // try to use the array index '-'\n json::const_reference ref = j.at(\"/array/-\"_json_pointer);\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.403\n try\n {\n // try to use a JSON pointer to a nonexistent object key\n json::const_reference ref = j.at(\"/foo\"_json_pointer);\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // out_of_range.404\n try\n {\n // try to use a JSON pointer that cannot be resolved\n json::const_reference ref = j.at(\"/number/foo\"_json_pointer);\n }\n catch (const json::out_of_range& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
1\n\"foo\"\n[1,2]\n2\n[json.exception.parse_error.109] parse error: array index 'one' is not a number\n[json.exception.out_of_range.401] array index 4 is out of range\n[json.exception.out_of_range.402] array index '-' (2) is out of range\n[json.exception.out_of_range.403] key 'foo' not found\n[json.exception.out_of_range.404] unresolved reference token 'foo'\noperator[] for unchecked access by referencevalue for access with default valuereference back();\n\nconst_reference back() const;\nReturns a reference to the last element in the container. For a JSON container c, the expression c.back() is equivalent to
auto tmp = c.end();\n--tmp;\nreturn *tmp;\nIn the case of a structured type (array or object), a reference to the last element is returned. In the case of number, string, boolean, or binary values, a reference to the value is returned.
"},{"location":"api/basic_json/back/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/back/#exceptions","title":"Exceptions","text":"If the JSON value is null, exception invalid_iterator.214 is thrown.
Constant.
"},{"location":"api/basic_json/back/#notes","title":"Notes","text":"Precondition
The array or object must not be empty. Calling back on an empty array or object yields undefined behavior.
The following code shows an example for back().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_object_empty(json::value_t::object);\n json j_array = {1, 2, 4, 8, 16};\n json j_array_empty(json::value_t::array);\n json j_string = \"Hello, world\";\n\n // call back()\n std::cout << j_boolean.back() << '\\n';\n std::cout << j_number_integer.back() << '\\n';\n std::cout << j_number_float.back() << '\\n';\n std::cout << j_object.back() << '\\n';\n //std::cout << j_object_empty.back() << '\\n'; // undefined behavior\n std::cout << j_array.back() << '\\n';\n //std::cout << j_array_empty.back() << '\\n'; // undefined behavior\n std::cout << j_string.back() << '\\n';\n\n // back() called on a null value\n try\n {\n json j_null;\n j_null.back();\n }\n catch (const json::invalid_iterator& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
true\n17\n23.42\n2\n16\n\"Hello, world\"\n[json.exception.invalid_iterator.214] cannot get value\n// (1)\nbasic_json(const value_t v);\n\n// (2)\nbasic_json(std::nullptr_t = nullptr) noexcept;\n\n// (3)\ntemplate<typename CompatibleType>\nbasic_json(CompatibleType&& val) noexcept(noexcept(\n JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),\n std::forward<CompatibleType>(val))));\n\n// (4)\ntemplate<typename BasicJsonType>\nbasic_json(const BasicJsonType& val);\n\n// (5)\nbasic_json(initializer_list_t init,\n bool type_deduction = true,\n value_t manual_type = value_t::array);\n\n// (6)\nbasic_json(size_type cnt, const basic_json& val);\n\n// (7)\nbasic_json(iterator first, iterator last);\nbasic_json(const_iterator first, const_iterator last);\n\n// (8)\nbasic_json(const basic_json& other);\n\n// (9)\nbasic_json(basic_json&& other) noexcept;\nCreate an empty JSON value with a given type. The value will be default initialized with an empty value which depends on the type:
Value type initial value nullnull boolean false string \"\" number 0 object {} array [] binary empty array The postcondition of this constructor can be restored by calling clear().
Create a null JSON value. It either takes a null pointer as parameter (explicitly creating null) or no parameter (implicitly creating null). The passed null pointer itself is not read -- it is only used to choose the right constructor.
This is a \"catch all\" constructor for all compatible JSON types; that is, types for which a to_json() method exists. The constructor forwards the parameter val to that method (to json_serializer<U>::to_json method with U = uncvref_t<CompatibleType>, to be exact).
Template type CompatibleType includes, but is not limited to, the following types:
array_t and all kinds of compatible containers such as std::vector, std::deque, std::list, std::forward_list, std::array, std::valarray, std::set, std::unordered_set, std::multiset, and std::unordered_multiset with a value_type from which a basic_json value can be constructed.object_t and all kinds of compatible associative containers such as std::map, std::unordered_map, std::multimap, and std::unordered_multimap with a key_type compatible to string_t and a value_type from which a basic_json value can be constructed.string_t, string literals, and all compatible string containers can be used.number_integer_t, number_unsigned_t, number_float_t, and all convertible number types such as int, size_t, int64_t, float or double can be used.boolean_t / bool can be used.binary_t / std::vector<uint8_t> may be used; unfortunately because string literals cannot be distinguished from binary character arrays by the C++ type system, all types compatible with const char* will be directed to the string constructor instead. This is both for backwards compatibility and due to the fact that a binary type is not a standard JSON type.See the examples below.
This is a constructor for existing basic_json types. It does not hijack copy/move constructors, since the parameter has different template arguments than the current ones.
The constructor tries to convert the internal m_value of the parameter. Each member value (object, array, string, etc.) is serialized via the corresponding to_json() overload. For objects and strings, the conversion requires that the target basic_json type's object_t::key_type (or string_t) be directly constructible from the source type's corresponding member type via is_constructible. If this requirement is not met, the conversion does not fail to compile; instead, it silently falls back to the array-conversion path, which represents objects as arrays of [key, value] pairs and strings as arrays of character codes. This is a known limitation tracked in issue #3425.
Creates a JSON value of type array or object from the passed initializer list init. In case type_deduction is true (default), the type of the JSON value to be created is deducted from the initializer list init according to the following rules:
{} is created.The rules aim to create the best fit between a C++ initializer list and JSON values. The rationale is as follows:
{} which is exactly an empty JSON object.With the rules described above, the following JSON values cannot be expressed by an initializer list:
[]): use array(initializer_list_t) with an empty initializer list in this casearray(initializer_list_t) with the same initializer list in this caseFunction array() and object() force array and object creation from initializer lists, respectively.
Constructs a JSON array value by creating cnt copies of a passed value. In case cnt is 0, an empty array is created.
Constructs the JSON value with the contents of the range [first, last). The semantics depend on the different types a JSON value can have:
null type, invalid_iterator.206 is thrown.first must be begin() and last must be end(). In this case, the value is copied. Otherwise, invalid_iterator.204 is thrown.std::vector or std::map; that is, a JSON array or object is constructed from the values in the range.Creates a copy of a given JSON value.
Move constructor. Constructs a JSON value with the contents of the given value other using move semantics. It \"steals\" the resources from other and leaves it as JSON null value.
CompatibleType a type such that:
CompatibleType is not derived from std::istream,CompatibleType is not basic_json (to avoid hijacking copy/move constructors),CompatibleType is not a different basic_json type (i.e. with different template arguments)CompatibleType is not a basic_json nested type (e.g., json_pointer, iterator, etc.)json_serializer<U> (with U = uncvref_t<CompatibleType>) has a to_json(basic_json_t&, CompatibleType&&) methodBasicJsonType: a type such that:
BasicJsonType is a basic_json type.BasicJsonType has different template arguments than basic_json_t.Note: For cross-basic_json conversions to produce correct results, the target basic_json's object_t::key_type and string_t must be directly constructible from the source basic_json's corresponding types. See the description of overload (4) above for details on what happens when this requirement is not met.
U: uncvref_t<CompatibleType>"},{"location":"api/basic_json/basic_json/#parameters","title":"Parameters","text":"v (in) the type of the value to create val (in) the value to be forwarded to the respective constructor init (in) initializer list with JSON values type_deduction (in) internal parameter; when set to true, the type of the JSON value is deducted from the initializer list init; when set to false, the type provided via manual_type is forced. This mode is used by the functions array(initializer_list_t) and object(initializer_list_t). manual_type (in) internal parameter; when type_deduction is set to false, the created JSON value will use the provided type (only value_t::array and value_t::object are valid); when type_deduction is set to true, this parameter has no effect cnt (in) the number of JSON copies of val to create first (in) the beginning of the range to copy from (included) last (in) the end of the range to copy from (excluded) other (in) the JSON value to copy/move"},{"location":"api/basic_json/basic_json/#exception-safety","title":"Exception safety","text":"to_json() function was provided), a strong guarantee holds: if an exception is thrown, there are no changes to any JSON value.to_json() function was provided), a strong guarantee holds: if an exception is thrown, there are no changes to any JSON value.type_error.301 if type_deduction is false, manual_type is value_t::object, but init contains an element which is not a pair whose first element is a string. In this case, the constructor could not create an object. If type_deduction would have been true, an array would have been created. See object(initializer_list_t) for an example.invalid_iterator.201 if iterators first and last are not compatible (i.e., do not belong to the same JSON value). In this case, the range [first, last) is undefined.invalid_iterator.204 if iterators first and last belong to a primitive type (number, boolean, or string), but first does not point to the first element anymore. In this case, the range [first, last) is undefined. See the example code below.invalid_iterator.206 if iterators first and last belong to a null value. In this case, the range [first, last) is undefined.val, also depending on the implementation of the called to_json() method.val, also depending on the implementation of the called to_json() method.init.cnt.first and last.other.Overload 5:
Empty initializer list
When used without parentheses around an empty initializer list, basic_json() is called instead of this function, yielding the JSON null value.
Overload 7:
Preconditions
first and last must be initialized. **This precondition is enforced with a runtime assertion.[first, last) is valid. Usually, this precondition cannot be checked efficiently. Only certain edge cases are detected; see the description of the exceptions above. A violation of this precondition yields undefined behavior.Runtime assertion
A precondition is enforced with a runtime assertion.
Overload 8:
Postcondition
*this == other
Overload 9:
Postconditions
`*this has the same value as other before the call.other is a JSON null valueThe following code shows the constructor for different value_t values.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create the different JSON values with default values\n json j_null(json::value_t::null);\n json j_boolean(json::value_t::boolean);\n json j_number_integer(json::value_t::number_integer);\n json j_number_float(json::value_t::number_float);\n json j_object(json::value_t::object);\n json j_array(json::value_t::array);\n json j_string(json::value_t::string);\n\n // serialize the JSON values\n std::cout << j_null << '\\n';\n std::cout << j_boolean << '\\n';\n std::cout << j_number_integer << '\\n';\n std::cout << j_number_float << '\\n';\n std::cout << j_object << '\\n';\n std::cout << j_array << '\\n';\n std::cout << j_string << '\\n';\n}\nOutput:
null\nfalse\n0\n0.0\n{}\n[]\n\"\"\nnull object The following code shows the constructor with and without a null pointer parameter.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // implicitly create a JSON null value\n json j1;\n\n // explicitly create a JSON null value\n json j2(nullptr);\n\n // serialize the JSON null value\n std::cout << j1 << '\\n' << j2 << '\\n';\n}\nOutput:
null\nnull\nThe following code shows the constructor with several compatible types.
#include <iostream>\n#include <deque>\n#include <list>\n#include <forward_list>\n#include <set>\n#include <unordered_map>\n#include <unordered_set>\n#include <valarray>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // ============\n // object types\n // ============\n\n // create an object from an object_t value\n json::object_t object_value = { {\"one\", 1}, {\"two\", 2} };\n json j_object_t(object_value);\n\n // create an object from std::map\n std::map<std::string, int> c_map\n {\n {\"one\", 1}, {\"two\", 2}, {\"three\", 3}\n };\n json j_map(c_map);\n\n // create an object from std::unordered_map\n std::unordered_map<const char*, double> c_umap\n {\n {\"one\", 1.2}, {\"two\", 2.3}, {\"three\", 3.4}\n };\n json j_umap(c_umap);\n\n // create an object from std::multimap\n std::multimap<std::string, bool> c_mmap\n {\n {\"one\", true}, {\"two\", true}, {\"three\", false}, {\"three\", true}\n };\n json j_mmap(c_mmap); // only one entry for key \"three\" is used\n\n // create an object from std::unordered_multimap\n std::unordered_multimap<std::string, bool> c_ummap\n {\n {\"one\", true}, {\"two\", true}, {\"three\", false}, {\"three\", true}\n };\n json j_ummap(c_ummap); // only one entry for key \"three\" is used\n\n // serialize the JSON objects\n std::cout << j_object_t << '\\n';\n std::cout << j_map << '\\n';\n std::cout << j_umap << '\\n';\n std::cout << j_mmap << '\\n';\n std::cout << j_ummap << \"\\n\\n\";\n\n // ===========\n // array types\n // ===========\n\n // create an array from an array_t value\n json::array_t array_value = {\"one\", \"two\", 3, 4.5, false};\n json j_array_t(array_value);\n\n // create an array from std::vector\n std::vector<int> c_vector {1, 2, 3, 4};\n json j_vec(c_vector);\n\n // create an array from std::valarray\n std::valarray<short> c_valarray {10, 9, 8, 7};\n json j_valarray(c_valarray);\n\n // create an array from std::deque\n std::deque<double> c_deque {1.2, 2.3, 3.4, 5.6};\n json j_deque(c_deque);\n\n // create an array from std::list\n std::list<bool> c_list {true, true, false, true};\n json j_list(c_list);\n\n // create an array from std::forward_list\n std::forward_list<std::int64_t> c_flist {12345678909876, 23456789098765, 34567890987654, 45678909876543};\n json j_flist(c_flist);\n\n // create an array from std::array\n std::array<unsigned long, 4> c_array {{1, 2, 3, 4}};\n json j_array(c_array);\n\n // create an array from std::set\n std::set<std::string> c_set {\"one\", \"two\", \"three\", \"four\", \"one\"};\n json j_set(c_set); // only one entry for \"one\" is used\n\n // create an array from std::unordered_set\n std::unordered_set<std::string> c_uset {\"one\", \"two\", \"three\", \"four\", \"one\"};\n json j_uset(c_uset); // only one entry for \"one\" is used\n\n // create an array from std::multiset\n std::multiset<std::string> c_mset {\"one\", \"two\", \"one\", \"four\"};\n json j_mset(c_mset); // both entries for \"one\" are used\n\n // create an array from std::unordered_multiset\n std::unordered_multiset<std::string> c_umset {\"one\", \"two\", \"one\", \"four\"};\n json j_umset(c_umset); // both entries for \"one\" are used\n\n // serialize the JSON arrays\n std::cout << j_array_t << '\\n';\n std::cout << j_vec << '\\n';\n std::cout << j_valarray << '\\n';\n std::cout << j_deque << '\\n';\n std::cout << j_list << '\\n';\n std::cout << j_flist << '\\n';\n std::cout << j_array << '\\n';\n std::cout << j_set << '\\n';\n std::cout << j_uset << '\\n';\n std::cout << j_mset << '\\n';\n std::cout << j_umset << \"\\n\\n\";\n\n // ============\n // string types\n // ============\n\n // create string from a string_t value\n json::string_t string_value = \"The quick brown fox jumps over the lazy dog.\";\n json j_string_t(string_value);\n\n // create a JSON string directly from a string literal\n json j_string_literal(\"The quick brown fox jumps over the lazy dog.\");\n\n // create string from std::string\n std::string s_stdstring = \"The quick brown fox jumps over the lazy dog.\";\n json j_stdstring(s_stdstring);\n\n // serialize the JSON strings\n std::cout << j_string_t << '\\n';\n std::cout << j_string_literal << '\\n';\n std::cout << j_stdstring << \"\\n\\n\";\n\n // ============\n // number types\n // ============\n\n // create a JSON number from number_integer_t\n json::number_integer_t value_integer_t = -42;\n json j_integer_t(value_integer_t);\n\n // create a JSON number from number_unsigned_t\n json::number_integer_t value_unsigned_t = 17;\n json j_unsigned_t(value_unsigned_t);\n\n // create a JSON number from an anonymous enum\n enum { enum_value = 17 };\n json j_enum(enum_value);\n\n // create values of different integer types\n short n_short = 42;\n int n_int = -23;\n long n_long = 1024;\n int_least32_t n_int_least32_t = -17;\n uint8_t n_uint8_t = 8;\n\n // create (integer) JSON numbers\n json j_short(n_short);\n json j_int(n_int);\n json j_long(n_long);\n json j_int_least32_t(n_int_least32_t);\n json j_uint8_t(n_uint8_t);\n\n // create values of different floating-point types\n json::number_float_t v_ok = 3.141592653589793;\n json::number_float_t v_nan = NAN;\n json::number_float_t v_infinity = INFINITY;\n\n // create values of different floating-point types\n float n_float = 42.23;\n float n_float_nan = 1.0f / 0.0f;\n double n_double = 23.42;\n\n // create (floating point) JSON numbers\n json j_ok(v_ok);\n json j_nan(v_nan);\n json j_infinity(v_infinity);\n json j_float(n_float);\n json j_float_nan(n_float_nan);\n json j_double(n_double);\n\n // serialize the JSON numbers\n std::cout << j_integer_t << '\\n';\n std::cout << j_unsigned_t << '\\n';\n std::cout << j_enum << '\\n';\n std::cout << j_short << '\\n';\n std::cout << j_int << '\\n';\n std::cout << j_long << '\\n';\n std::cout << j_int_least32_t << '\\n';\n std::cout << j_uint8_t << '\\n';\n std::cout << j_ok << '\\n';\n std::cout << j_nan << '\\n';\n std::cout << j_infinity << '\\n';\n std::cout << j_float << '\\n';\n std::cout << j_float_nan << '\\n';\n std::cout << j_double << \"\\n\\n\";\n\n // =============\n // boolean types\n // =============\n\n // create boolean values\n json j_truth = true;\n json j_falsity = false;\n\n // serialize the JSON booleans\n std::cout << j_truth << '\\n';\n std::cout << j_falsity << '\\n';\n}\nOutput:
{\"one\":1,\"two\":2}\n{\"one\":1,\"three\":3,\"two\":2}\n{\"one\":1.2,\"three\":3.4,\"two\":2.3}\n{\"one\":true,\"three\":false,\"two\":true}\n{\"one\":true,\"three\":false,\"two\":true}\n\n[\"one\",\"two\",3,4.5,false]\n[1,2,3,4]\n[10,9,8,7]\n[1.2,2.3,3.4,5.6]\n[true,true,false,true]\n[12345678909876,23456789098765,34567890987654,45678909876543]\n[1,2,3,4]\n[\"four\",\"one\",\"three\",\"two\"]\n[\"four\",\"three\",\"two\",\"one\"]\n[\"four\",\"one\",\"one\",\"two\"]\n[\"four\",\"two\",\"one\",\"one\"]\n\n\"The quick brown fox jumps over the lazy dog.\"\n\"The quick brown fox jumps over the lazy dog.\"\n\"The quick brown fox jumps over the lazy dog.\"\n\n-42\n17\n17\n42\n-23\n1024\n-17\n8\n3.141592653589793\nnull\nnull\n42.22999954223633\nnull\n23.42\n\ntrue\nfalse\nNote the output is platform-dependent.
Example: (5) create a container (array or object) from an initializer listThe example below shows how JSON values are created from initializer lists.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_empty_init_list = json({});\n json j_object = { {\"one\", 1}, {\"two\", 2} };\n json j_array = {1, 2, 3, 4};\n json j_nested_object = { {\"one\", {1}}, {\"two\", {1, 2}} };\n json j_nested_array = { {{1}, \"one\"}, {{1, 2}, \"two\"} };\n\n // serialize the JSON value\n std::cout << j_empty_init_list << '\\n';\n std::cout << j_object << '\\n';\n std::cout << j_array << '\\n';\n std::cout << j_nested_object << '\\n';\n std::cout << j_nested_array << '\\n';\n}\nOutput:
{}\n{\"one\":1,\"two\":2}\n[1,2,3,4]\n{\"one\":[1],\"two\":[1,2]}\n[[[1],\"one\"],[[1,2],\"two\"]]\nThe following code shows examples for creating arrays with several copies of a given value.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array by creating copies of a JSON value\n json value = \"Hello\";\n json array_0 = json(0, value);\n json array_1 = json(1, value);\n json array_5 = json(5, value);\n\n // serialize the JSON arrays\n std::cout << array_0 << '\\n';\n std::cout << array_1 << '\\n';\n std::cout << array_5 << '\\n';\n}\nOutput:
[]\n[\"Hello\"]\n[\"Hello\",\"Hello\",\"Hello\",\"Hello\",\"Hello\"]\nThe example below shows several ways to create JSON values by specifying a subrange with iterators.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_array = {\"alpha\", \"bravo\", \"charly\", \"delta\", \"easy\"};\n json j_number = 42;\n json j_object = {{\"one\", \"eins\"}, {\"two\", \"zwei\"}};\n\n // create copies using iterators\n json j_array_range(j_array.begin() + 1, j_array.end() - 2);\n json j_number_range(j_number.begin(), j_number.end());\n json j_object_range(j_object.begin(), j_object.find(\"two\"));\n\n // serialize the values\n std::cout << j_array_range << '\\n';\n std::cout << j_number_range << '\\n';\n std::cout << j_object_range << '\\n';\n\n // example for an exception\n try\n {\n json j_invalid(j_number.begin() + 1, j_number.end());\n }\n catch (const json::invalid_iterator& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[\"bravo\",\"charly\"]\n42\n{\"one\":\"eins\"}\n[json.exception.invalid_iterator.204] iterators out of range\nThe following code shows an example for the copy constructor.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON array\n json j1 = {\"one\", \"two\", 3, 4.5, false};\n\n // create a copy\n json j2(j1);\n\n // serialize the JSON array\n std::cout << j1 << \" = \" << j2 << '\\n';\n std::cout << std::boolalpha << (j1 == j2) << '\\n';\n}\nOutput:
[\"one\",\"two\",3,4.5,false] = [\"one\",\"two\",3,4.5,false]\ntrue\nThe code below shows the move constructor explicitly called via std::move.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value\n json a = 23;\n\n // move contents of a to b\n json b(std::move(a));\n\n // serialize the JSON arrays\n std::cout << a << '\\n';\n std::cout << b << '\\n';\n}\nOutput:
null\n23\niterator begin() noexcept;\nconst_iterator begin() const noexcept;\nReturns an iterator to the first element.
"},{"location":"api/basic_json/begin/#return-value","title":"Return value","text":"iterator to the first element
"},{"location":"api/basic_json/begin/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/begin/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/begin/#examples","title":"Examples","text":"ExampleThe following code shows an example for begin().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array value\n json array = {1, 2, 3, 4, 5};\n\n // get an iterator to the first element\n json::iterator it = array.begin();\n\n // serialize the element that the iterator points to\n std::cout << *it << '\\n';\n}\nOutput:
1\n// (1)\nstatic basic_json binary(const typename binary_t::container_type& init);\nstatic basic_json binary(typename binary_t::container_type&& init);\n\n// (2)\nstatic basic_json binary(const typename binary_t::container_type& init,\n std::uint8_t subtype);\nstatic basic_json binary(typename binary_t::container_type&& init,\n std::uint8_t subtype);\nBinary values are part of various binary formats, such as CBOR, MessagePack, and BSON. This constructor is used to create a value for serialization to those formats.
"},{"location":"api/basic_json/binary/#parameters","title":"Parameters","text":"init (in) container containing bytes to use as a binary type subtype (in) subtype to use in CBOR, MessagePack, and BSON"},{"location":"api/basic_json/binary/#return-value","title":"Return value","text":"JSON binary array value
"},{"location":"api/basic_json/binary/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/binary/#complexity","title":"Complexity","text":"Linear in the size of init; constant for typename binary_t::container_type&& init versions.
Note, this function exists because of the difficulty in correctly specifying the correct template overload in the standard value ctor, as both JSON arrays and JSON binary arrays are backed with some form of a std::vector. Because JSON binary arrays are a non-standard extension, it was decided that it would be best to prevent automatic initialization of a binary array type, for backwards compatibility and so it does not happen on accident.
The following code shows how to create a binary value.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a binary vector\n std::vector<std::uint8_t> vec = {0xCA, 0xFE, 0xBA, 0xBE};\n\n // create a binary JSON value with subtype 42\n json j = json::binary(vec, 42);\n\n // output type and subtype\n std::cout << \"type: \" << j.type_name() << \", subtype: \" << j.get_binary().subtype() << std::endl;\n}\nOutput:
type: binary, subtype: 42\nusing binary_t = byte_container_with_subtype<BinaryType>;\nThis type is a type designed to carry binary data that appears in various serialized formats, such as CBOR's Major Type 2, MessagePack's bin, and BSON's generic binary subtype. This type is NOT a part of standard JSON and exists solely for compatibility with these binary types. As such, it is simply defined as an ordered sequence of zero or more byte values.
Additionally, as an implementation detail, the subtype of the binary data is carried around as a std::uint64_t, which is compatible with both of the binary data formats that use binary subtyping, (though the specific numbering is incompatible with each other, and it is up to the user to translate between them). The subtype is added to BinaryType via the helper type byte_container_with_subtype.
CBOR's RFC 7049 describes this type as:
Major type 2: a byte string. The string's length in bytes is represented following the rules for positive integers (major type 0).
MessagePack's documentation on the bin type family describes this type as:
Bin format family stores a byte array in 2, 3, or 5 bytes of extra bytes in addition to the size of the byte array.
BSON's specifications describe several binary types; however, this type is intended to represent the generic binary type which has the description:
Generic binary subtype - This is the most commonly used binary subtype and should be the 'default' for drivers and tools.
None of these impose any limitations on the internal representation other than the basic unit of storage be some type of array whose parts are decomposable into bytes.
The default representation of this binary format is a std::vector<std::uint8_t>, which is a very common way to represent a byte array in modern C++.
BinaryType container type to store arrays"},{"location":"api/basic_json/binary_t/#notes","title":"Notes","text":""},{"location":"api/basic_json/binary_t/#default-type","title":"Default type","text":"The default values for BinaryType is std::vector<std::uint8_t>.
Binary Arrays are stored as pointers in a basic_json type. That is, for any access to array values, a pointer of the type binary_t* must be dereferenced.
CBOR
MessagePack
BSON
The following code shows that binary_t is by default, a typedef to nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha << std::is_same<nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>, json::binary_t>::value << std::endl;\n}\nOutput:
true\nstd::uint64_t in version 3.10.0.using boolean_t = BooleanType;\nThe type used to store JSON booleans.
RFC 8259 implicitly describes a boolean as a type which differentiates the two literals true and false.
To store boolean values in C++, a type is defined by the template parameter BooleanType which chooses the type to use.
With the default values for BooleanType (bool), the default value for boolean_t is bool.
Boolean values are stored directly inside a basic_json type.
The following code shows that boolean_t is by default, a typedef to bool.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha << std::is_same<bool, json::boolean_t>::value << std::endl;\n}\nOutput:
true\nconst_iterator cbegin() const noexcept;\nReturns an iterator to the first element.
"},{"location":"api/basic_json/cbegin/#return-value","title":"Return value","text":"iterator to the first element
"},{"location":"api/basic_json/cbegin/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/cbegin/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/cbegin/#examples","title":"Examples","text":"ExampleThe following code shows an example for cbegin().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array value\n const json array = {1, 2, 3, 4, 5};\n\n // get an iterator to the first element\n json::const_iterator it = array.cbegin();\n\n // serialize the element that the iterator points to\n std::cout << *it << '\\n';\n}\nOutput:
1\nenum class cbor_tag_handler_t\n{\n error,\n ignore,\n store\n};\nThis enumeration is used in the from_cbor function to choose how to treat tags:
parse_error exception in case of a tag ignore ignore tags store store tagged values as binary container with subtype (for bytes 0xd8..0xdb)"},{"location":"api/basic_json/cbor_tag_handler_t/#examples","title":"Examples","text":"Example The example below shows how the different values of the cbor_tag_handler_t influence the behavior of from_cbor when reading a tagged byte string.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // tagged byte string\n std::vector<std::uint8_t> vec = {{0xd8, 0x42, 0x44, 0xcA, 0xfe, 0xba, 0xbe}};\n\n // cbor_tag_handler_t::error throws\n try\n {\n auto b_throw_on_tag = json::from_cbor(vec, true, true, json::cbor_tag_handler_t::error);\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n // cbor_tag_handler_t::ignore ignores the tag\n auto b_ignore_tag = json::from_cbor(vec, true, true, json::cbor_tag_handler_t::ignore);\n std::cout << b_ignore_tag << std::endl;\n\n // cbor_tag_handler_t::store stores the tag as binary subtype\n auto b_store_tag = json::from_cbor(vec, true, true, json::cbor_tag_handler_t::store);\n std::cout << b_store_tag << std::endl;\n}\nOutput:
[json.exception.parse_error.112] parse error at byte 1: syntax error while parsing CBOR value: invalid byte: 0xD8\n{\"bytes\":[202,254,186,190],\"subtype\":null}\n{\"bytes\":[202,254,186,190],\"subtype\":66}\nstore in 3.10.0.const_iterator cend() const noexcept;\nReturns an iterator to one past the last element.
"},{"location":"api/basic_json/cend/#return-value","title":"Return value","text":"iterator one past the last element
"},{"location":"api/basic_json/cend/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/cend/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/cend/#examples","title":"Examples","text":"ExampleThe following code shows an example for cend().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array value\n json array = {1, 2, 3, 4, 5};\n\n // get an iterator to one past the last element\n json::const_iterator it = array.cend();\n\n // decrement the iterator to point to the last element\n --it;\n\n // serialize the element that the iterator points to\n std::cout << *it << '\\n';\n}\nOutput:
5\nvoid clear() noexcept;\nClears the content of a JSON value and resets it to the default value as if basic_json(value_t) would have been called with the current value type from type():
null boolean false string \"\" number 0 binary An empty byte vector object {} array [] Has the same effect as calling
*this = basic_json(type());\nNo-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/clear/#complexity","title":"Complexity","text":"Linear in the size of the JSON value.
"},{"location":"api/basic_json/clear/#notes","title":"Notes","text":"All iterators, pointers, and references related to this container are invalidated.
"},{"location":"api/basic_json/clear/#examples","title":"Examples","text":"ExampleThe example below shows the effect of clear() to different JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n\n // call clear()\n j_null.clear();\n j_boolean.clear();\n j_number_integer.clear();\n j_number_float.clear();\n j_object.clear();\n j_array.clear();\n j_string.clear();\n\n // serialize the cleared values()\n std::cout << j_null << '\\n';\n std::cout << j_boolean << '\\n';\n std::cout << j_number_integer << '\\n';\n std::cout << j_number_float << '\\n';\n std::cout << j_object << '\\n';\n std::cout << j_array << '\\n';\n std::cout << j_string << '\\n';\n}\nOutput:
null\nfalse\n0\n0.0\n{}\n[]\n\"\"\n// (1)\nbool contains(const typename object_t::key_type& key) const;\n\n// (2)\ntemplate<typename KeyType>\nbool contains(KeyType&& key) const;\n\n// (3)\nbool contains(const json_pointer& ptr) const;\nkey. If the element is not found or the JSON value is not an object, false is returned.KeyType is comparable with typename object_t::key_type and typename object_comparator_t::is_transparent denotes a type.ptr can be resolved in the current JSON value.KeyType A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17)."},{"location":"api/basic_json/contains/#parameters","title":"Parameters","text":"key (in) key value to check its existence. ptr (in) JSON pointer to check its existence."},{"location":"api/basic_json/contains/#return-value","title":"Return value","text":"true if an element with specified key exists. If no such element with such a key is found or the JSON value is not an object, false is returned.true if the JSON pointer can be resolved to a stored value, false otherwise.Strong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/contains/#exceptions","title":"Exceptions","text":"Logarithmic in the size of the JSON object.
"},{"location":"api/basic_json/contains/#notes","title":"Notes","text":"false when executed on a JSON type that is not an object.Postconditions
If j.contains(x) returns true for a key or JSON pointer x, then it is safe to call j[x].
The example shows how contains() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create some JSON values\n json j_object = R\"( {\"key\": \"value\"} )\"_json;\n json j_array = R\"( [1, 2, 3] )\"_json;\n\n // call contains\n std::cout << std::boolalpha <<\n \"j_object contains 'key': \" << j_object.contains(\"key\") << '\\n' <<\n \"j_object contains 'another': \" << j_object.contains(\"another\") << '\\n' <<\n \"j_array contains 'key': \" << j_array.contains(\"key\") << std::endl;\n}\nOutput:
j_object contains 'key': true\nj_object contains 'another': false\nj_array contains 'key': false\nThe example shows how contains() is used.
#include <iostream>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create some JSON values\n json j_object = R\"( {\"key\": \"value\"} )\"_json;\n json j_array = R\"( [1, 2, 3] )\"_json;\n\n // call contains\n std::cout << std::boolalpha <<\n \"j_object contains 'key': \" << j_object.contains(\"key\"sv) << '\\n' <<\n \"j_object contains 'another': \" << j_object.contains(\"another\"sv) << '\\n' <<\n \"j_array contains 'key': \" << j_array.contains(\"key\"sv) << std::endl;\n}\nOutput:
j_object contains 'key': true\nj_object contains 'another': false\nj_array contains 'key': false\nThe example shows how contains() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j =\n {\n {\"number\", 1}, {\"string\", \"foo\"}, {\"array\", {1, 2}}\n };\n\n std::cout << std::boolalpha\n << j.contains(\"/number\"_json_pointer) << '\\n'\n << j.contains(\"/string\"_json_pointer) << '\\n'\n << j.contains(\"/array\"_json_pointer) << '\\n'\n << j.contains(\"/array/1\"_json_pointer) << '\\n'\n << j.contains(\"/array/-\"_json_pointer) << '\\n'\n << j.contains(\"/array/4\"_json_pointer) << '\\n'\n << j.contains(\"/baz\"_json_pointer) << std::endl;\n\n try\n {\n // try to use an array index with leading '0'\n j.contains(\"/array/01\"_json_pointer);\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n try\n {\n // try to use an array index that is not a number\n j.contains(\"/array/one\"_json_pointer);\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
true\ntrue\ntrue\ntrue\nfalse\nfalse\nfalse\nKeyType to support comparable types in version 3.11.0.// (1)\nsize_type count(const typename object_t::key_type& key) const;\n\n// (2)\ntemplate<typename KeyType>\nsize_type count(KeyType&& key) const;\nkey. If ObjectType is the default std::map type, the return value will always be 0 (key was not found) or 1 (key was found).KeyType is comparable with typename object_t::key_type and typename object_comparator_t::is_transparent denotes a type.KeyType A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17)."},{"location":"api/basic_json/count/#parameters","title":"Parameters","text":"key (in) key value of the element to count."},{"location":"api/basic_json/count/#return-value","title":"Return value","text":"Number of elements with key key. If the JSON value is not an object, the return value will be 0.
Strong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/count/#complexity","title":"Complexity","text":"Logarithmic in the size of the JSON object.
"},{"location":"api/basic_json/count/#notes","title":"Notes","text":"This method always returns 0 when executed on a JSON type that is not an object.
The example shows how count() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n\n // call count()\n auto count_two = j_object.count(\"two\");\n auto count_three = j_object.count(\"three\");\n\n // print values\n std::cout << \"number of elements with key \\\"two\\\": \" << count_two << '\\n';\n std::cout << \"number of elements with key \\\"three\\\": \" << count_three << '\\n';\n}\nOutput:
number of elements with key \"two\": 1\nnumber of elements with key \"three\": 0\nThe example shows how count() is used.
#include <iostream>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n\n // call count()\n auto count_two = j_object.count(\"two\"sv);\n auto count_three = j_object.count(\"three\"sv);\n\n // print values\n std::cout << \"number of elements with key \\\"two\\\": \" << count_two << '\\n';\n std::cout << \"number of elements with key \\\"three\\\": \" << count_three << '\\n';\n}\nOutput:
number of elements with key \"two\": 1\nnumber of elements with key \"three\": 0\nkey type to KeyType&& in version 3.11.0.const_reverse_iterator crbegin() const noexcept;\nReturns an iterator to the reverse-beginning; that is, the last element.
"},{"location":"api/basic_json/crbegin/#return-value","title":"Return value","text":"reverse iterator to the last element
"},{"location":"api/basic_json/crbegin/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/crbegin/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/crbegin/#examples","title":"Examples","text":"ExampleThe following code shows an example for crbegin().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array value\n json array = {1, 2, 3, 4, 5};\n\n // get an iterator to the reverse-beginning\n json::const_reverse_iterator it = array.crbegin();\n\n // serialize the element that the iterator points to\n std::cout << *it << '\\n';\n}\nOutput:
5\nconst_reverse_iterator crend() const noexcept;\nReturns an iterator to the reverse-end; that is, one before the first element. This element acts as a placeholder, attempting to access it results in undefined behavior.
"},{"location":"api/basic_json/crend/#return-value","title":"Return value","text":"reverse iterator to the element following the last element
"},{"location":"api/basic_json/crend/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/crend/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/crend/#examples","title":"Examples","text":"ExampleThe following code shows an example for crend().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array value\n json array = {1, 2, 3, 4, 5};\n\n // get an iterator to the reverse-end\n json::const_reverse_iterator it = array.crend();\n\n // increment the iterator to point to the first element\n --it;\n\n // serialize the element that the iterator points to\n std::cout << *it << '\\n';\n}\nOutput:
1\nusing default_object_comparator_t = std::less<StringType>; // until C++14\n\nusing default_object_comparator_t = std::less<>; // since C++14\nThe default comparator used by object_t.
Since C++14 a transparent comparator is used which prevents unnecessary string construction when looking up a key in an object.
The actual comparator used depends on object_t and can be obtained via object_comparator_t.
The example below demonstrates the default comparator.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha\n << \"one < two : \" << json::default_object_comparator_t{}(\"one\", \"two\") << \"\\n\"\n << \"three < four : \" << json::default_object_comparator_t{}(\"three\", \"four\") << std::endl;\n}\nOutput:
one < two : true\nthree < four : false\nstatic basic_json diff(const basic_json& source,\n const basic_json& target);\nCreates a JSON Patch so that value source can be changed into the value target by calling patch function.
For two JSON values source and target, the following code yields always true:
source.patch(diff(source, target)) == target;\nsource (in) JSON value to compare from target (in) JSON value to compare against"},{"location":"api/basic_json/diff/#return-value","title":"Return value","text":"a JSON patch to convert the source to target
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/diff/#complexity","title":"Complexity","text":"Linear in the lengths of source and target.
Currently, only remove, add, and replace operations are generated.
The following code shows how a JSON patch is created as a diff for two JSON values.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // the source document\n json source = R\"(\n {\n \"baz\": \"qux\",\n \"foo\": \"bar\"\n }\n )\"_json;\n\n // the target document\n json target = R\"(\n {\n \"baz\": \"boo\",\n \"hello\": [\n \"world\"\n ]\n }\n )\"_json;\n\n // create the patch\n json patch = json::diff(source, target);\n\n // roundtrip\n json patched_source = source.patch(patch);\n\n // output patch and roundtrip result\n std::cout << std::setw(4) << patch << \"\\n\\n\"\n << std::setw(4) << patched_source << std::endl;\n}\nOutput:
[\n {\n \"op\": \"replace\",\n \"path\": \"/baz\",\n \"value\": \"boo\"\n },\n {\n \"op\": \"remove\",\n \"path\": \"/foo\"\n },\n {\n \"op\": \"add\",\n \"path\": \"/hello\",\n \"value\": [\n \"world\"\n ]\n }\n]\n\n{\n \"baz\": \"boo\",\n \"hello\": [\n \"world\"\n ]\n}\nstring_t dump(const int indent = -1,\n const char indent_char = ' ',\n const bool ensure_ascii = false,\n const error_handler_t error_handler = error_handler_t::strict) const;\nSerialization function for JSON values. The function tries to mimic Python's json.dumps() function, and currently supports its indent and ensure_ascii parameters.
indent (in) If indent is nonnegative, then array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. -1 (the default) selects the most compact representation. indent_char (in) The character to use for indentation if indent is greater than 0. The default is ensure_ascii (in) If ensure_ascii is true, all non-ASCII characters in the output are escaped with \\uXXXX sequences, and the result consists of ASCII characters only. error_handler (in) how to react on decoding errors; there are three possible values (see error_handler_t: strict (throws an exception in case a decoding error occurs; default), replace (replace invalid UTF-8 sequences with U+FFFD), and ignore (ignore invalid UTF-8 sequences during serialization; all valid bytes are copied to the output unchanged, and invalid bytes are dropped))."},{"location":"api/basic_json/dump/#return-value","title":"Return value","text":"string containing the serialization of the JSON value
"},{"location":"api/basic_json/dump/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
"},{"location":"api/basic_json/dump/#exceptions","title":"Exceptions","text":"Throws type_error.316 if a string stored inside the JSON value is not UTF-8 encoded and error_handler is set to strict
Linear.
"},{"location":"api/basic_json/dump/#notes","title":"Notes","text":"Binary values are serialized as an object containing two keys:
null if the binary has no subtypeThe following example shows the effect of different indent, indent_char, and ensure_ascii parameters to the result of the serialization.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hell\u00f6 \ud83d\ude00!\";\n\n // call dump()\n std::cout << \"objects:\" << '\\n'\n << j_object.dump() << \"\\n\\n\"\n << j_object.dump(-1) << \"\\n\\n\"\n << j_object.dump(0) << \"\\n\\n\"\n << j_object.dump(4) << \"\\n\\n\"\n << j_object.dump(1, '\\t') << \"\\n\\n\";\n\n std::cout << \"arrays:\" << '\\n'\n << j_array.dump() << \"\\n\\n\"\n << j_array.dump(-1) << \"\\n\\n\"\n << j_array.dump(0) << \"\\n\\n\"\n << j_array.dump(4) << \"\\n\\n\"\n << j_array.dump(1, '\\t') << \"\\n\\n\";\n\n std::cout << \"strings:\" << '\\n'\n << j_string.dump() << '\\n'\n << j_string.dump(-1, ' ', true) << '\\n';\n\n // create JSON value with invalid UTF-8 byte sequence\n json j_invalid = \"\u00e4\\xA9\u00fc\";\n try\n {\n std::cout << j_invalid.dump() << std::endl;\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n std::cout << \"string with replaced invalid characters: \"\n << j_invalid.dump(-1, ' ', false, json::error_handler_t::replace)\n << \"\\nstring with ignored invalid characters: \"\n << j_invalid.dump(-1, ' ', false, json::error_handler_t::ignore)\n << '\\n';\n}\nOutput:
objects:\n{\"one\":1,\"two\":2}\n\n{\"one\":1,\"two\":2}\n\n{\n\"one\": 1,\n\"two\": 2\n}\n\n{\n \"one\": 1,\n \"two\": 2\n}\n\n{\n \"one\": 1,\n \"two\": 2\n}\n\narrays:\n[1,2,4,8,16]\n\n[1,2,4,8,16]\n\n[\n1,\n2,\n4,\n8,\n16\n]\n\n[\n 1,\n 2,\n 4,\n 8,\n 16\n]\n\n[\n 1,\n 2,\n 4,\n 8,\n 16\n]\n\nstrings:\n\"Hell\u00f6 \ud83d\ude00!\"\n\"Hell\\u00f6 \\ud83d\\ude00!\"\n[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9\nstring with replaced invalid characters: \"\u00e4\ufffd\u00fc\"\nstring with ignored invalid characters: \"\u00e4\u00fc\"\nindent_char, option ensure_ascii and exceptions added in version 3.0.0.template<class... Args>\nstd::pair<iterator, bool> emplace(Args&& ... args);\nInserts a new element into a JSON object constructed in-place with the given args if there is no element with the key in the container. If the function is called on a JSON null value, an empty object is created before appending the value created from args.
Args compatible types to create a basic_json object"},{"location":"api/basic_json/emplace/#iterator-invalidation","title":"Iterator invalidation","text":"For ordered_json, adding a value to an object can yield a reallocation, in which case all iterators (including the end() iterator) and all references to the elements are invalidated.
args (in) arguments to forward to a constructor of basic_json"},{"location":"api/basic_json/emplace/#return-value","title":"Return value","text":"a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place.
Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
"},{"location":"api/basic_json/emplace/#exceptions","title":"Exceptions","text":"Throws type_error.311 when called on a type other than JSON object or null; example: \"cannot use emplace() with number\"
Logarithmic in the size of the container, O(log(size())).
The example shows how emplace() can be used to add elements to a JSON object. Note how the null value was silently converted to a JSON object. Further note how no value is added if there was already one value stored with the same key.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json object = {{\"one\", 1}, {\"two\", 2}};\n json null;\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n\n // add values\n auto res1 = object.emplace(\"three\", 3);\n null.emplace(\"A\", \"a\");\n null.emplace(\"B\", \"b\");\n\n // the following call will not add an object, because there is already\n // a value stored at key \"B\"\n auto res2 = null.emplace(\"B\", \"c\");\n\n // print values\n std::cout << object << '\\n';\n std::cout << *res1.first << \" \" << std::boolalpha << res1.second << '\\n';\n\n std::cout << null << '\\n';\n std::cout << *res2.first << \" \" << std::boolalpha << res2.second << '\\n';\n}\nOutput:
{\"one\":1,\"two\":2}\nnull\n{\"one\":1,\"three\":3,\"two\":2}\n3 true\n{\"A\":\"a\",\"B\":\"b\"}\n\"b\" false\ntemplate<class... Args>\nreference emplace_back(Args&& ... args);\nCreates a JSON value from the passed parameters args to the end of the JSON value. If the function is called on a JSON null value, an empty array is created before appending the value created from args.
Args compatible types to create a basic_json object"},{"location":"api/basic_json/emplace_back/#iterator-invalidation","title":"Iterator invalidation","text":"By adding an element to the end of the array, a reallocation can happen, in which case all iterators (including the end() iterator) and all references to the elements are invalidated. Otherwise, only the end() iterator is invalidated.
args (in) arguments to forward to a constructor of basic_json"},{"location":"api/basic_json/emplace_back/#return-value","title":"Return value","text":"reference to the inserted element
"},{"location":"api/basic_json/emplace_back/#exceptions","title":"Exceptions","text":"Throws type_error.311 when called on a type other than JSON array or null; example: \"cannot use emplace_back() with number\"
Amortized constant.
"},{"location":"api/basic_json/emplace_back/#examples","title":"Examples","text":"ExampleThe example shows how emplace_back() can be used to add elements to a JSON array. Note how the null value was silently converted to a JSON array.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json array = {1, 2, 3, 4, 5};\n json null;\n\n // print values\n std::cout << array << '\\n';\n std::cout << null << '\\n';\n\n // add values\n array.emplace_back(6);\n null.emplace_back(\"first\");\n null.emplace_back(3, \"second\");\n\n // print values\n std::cout << array << '\\n';\n std::cout << null << '\\n';\n}\nOutput:
[1,2,3,4,5]\nnull\n[1,2,3,4,5,6]\n[\"first\",[\"second\",\"second\",\"second\"]]\nbool empty() const noexcept;\nChecks if a JSON value has no elements (i.e., whether its size() is 0).
The return value depends on the different types and is defined as follows:
Value type return value nulltrue boolean false string false number false binary false object result of function object_t::empty() array result of function array_t::empty()"},{"location":"api/basic_json/empty/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/empty/#complexity","title":"Complexity","text":"Constant, as long as array_t and object_t satisfy the Container concept; that is, their empty() functions have constant complexity.
bool empty() const noexcept\n{\n return size() == 0;\n}\nThis function does not return whether a string stored as JSON value is empty -- it returns whether the JSON container itself is empty which is false in the case of a string.
The following code uses empty() to check if a JSON object contains any elements.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_object_empty(json::value_t::object);\n json j_array = {1, 2, 4, 8, 16};\n json j_array_empty(json::value_t::array);\n json j_string = \"Hello, world\";\n\n // call empty()\n std::cout << std::boolalpha;\n std::cout << j_null.empty() << '\\n';\n std::cout << j_boolean.empty() << '\\n';\n std::cout << j_number_integer.empty() << '\\n';\n std::cout << j_number_float.empty() << '\\n';\n std::cout << j_object.empty() << '\\n';\n std::cout << j_object_empty.empty() << '\\n';\n std::cout << j_array.empty() << '\\n';\n std::cout << j_array_empty.empty() << '\\n';\n std::cout << j_string.empty() << '\\n';\n}\nOutput:
true\nfalse\nfalse\nfalse\nfalse\ntrue\nfalse\ntrue\nfalse\nfalse for binary types in version 3.8.0.iterator end() noexcept;\nconst_iterator end() const noexcept;\nReturns an iterator to one past the last element.
"},{"location":"api/basic_json/end/#return-value","title":"Return value","text":"iterator one past the last element
"},{"location":"api/basic_json/end/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/end/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/end/#examples","title":"Examples","text":"ExampleThe following code shows an example for end().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array value\n json array = {1, 2, 3, 4, 5};\n\n // get an iterator to one past the last element\n json::iterator it = array.end();\n\n // decrement the iterator to point to the last element\n --it;\n\n // serialize the element that the iterator points to\n std::cout << *it << '\\n';\n}\nOutput:
5\n#if JSON_DIAGNOSTIC_POSITIONS\nconstexpr std::size_t end_pos() const noexcept;\n#endif\nReturns the position immediately following the last character of the JSON string from which the value was parsed from.
JSON type return value object position after the closing} array position after the closing ] string position after the closing \" number position after the last character boolean position after e null position after l"},{"location":"api/basic_json/end_pos/#return-value","title":"Return value","text":"the position of the character following the last character of the given value in the parsed JSON string, if the value was created by the parse function, or std::string::npos if the value was constructed otherwise
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/end_pos/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/end_pos/#notes","title":"Notes","text":"Note
The function is only available if macro JSON_DIAGNOSTIC_POSITIONS has been defined to 1 before including the library header.
Invalidation
The returned positions are only valid as long as the JSON value is not changed. The positions are not updated when the JSON value is changed.
"},{"location":"api/basic_json/end_pos/#examples","title":"Examples","text":"Example#include <iostream>\n\n#define JSON_DIAGNOSTIC_POSITIONS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::string json_string = R\"(\n {\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\n )\";\n json j = json::parse(json_string);\n\n std::cout << \"Root diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos: \" << j.start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j.end_pos() << \"\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"{\\n \\\"address\\\": {\\n \\\"street\\\": \\\"Fake Street\\\",\\n \\\"housenumber\\\": 1\\n }\\n }\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j.start_pos(), j.end_pos() - j.start_pos()) << \"\\n\\n\";\n\n std::cout << \"address diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"{ \\\"street\\\": \\\"Fake Street\\\",\\n \\\"housenumber\\\": 1\\n }\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"].start_pos(), j[\"address\"].end_pos() - j[\"address\"].start_pos()) << \"\\n\\n\";\n\n std::cout << \"street diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"][\"street\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"][\"street\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"\\\"Fake Street\\\"\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"][\"street\"].start_pos(), j[\"address\"][\"street\"].end_pos() - j[\"address\"][\"street\"].start_pos()) << \"\\n\\n\";\n\n std::cout << \"housenumber diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"][\"housenumber\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"][\"housenumber\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"1\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"][\"housenumber\"].start_pos(), j[\"address\"][\"housenumber\"].end_pos() - j[\"address\"][\"housenumber\"].start_pos()) << \"\\n\\n\";\n}\nOutput:
Root diagnostic positions: \n start_pos: 5\n end_pos:109\nOriginal string: \n{\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\nParsed string: \n{\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\n\naddress diagnostic positions: \n start_pos:26\n end_pos:103\n\nOriginal string: \n{ \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\nParsed string: \n{\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n\nstreet diagnostic positions: \n start_pos:50\n end_pos:63\n\nOriginal string: \n\"Fake Street\"\nParsed string: \n\"Fake Street\"\n\nhousenumber diagnostic positions: \n start_pos:92\n end_pos:93\n\nOriginal string: \n1\nParsed string: \n1\nThe output shows the start/end positions of all the objects and fields in the JSON string.
"},{"location":"api/basic_json/end_pos/#see-also","title":"See also","text":"// (1)\niterator erase(iterator pos);\nconst_iterator erase(const_iterator pos);\n\n// (2)\niterator erase(iterator first, iterator last);\nconst_iterator erase(const_iterator first, const_iterator last);\n\n// (3)\nsize_type erase(const typename object_t::key_type& key);\n\n// (4)\ntemplate<typename KeyType>\nsize_type erase(KeyType&& key);\n\n// (5)\nvoid erase(const size_type idx);\nRemoves an element from a JSON value specified by iterator pos. The iterator pos must be valid and dereferenceable. Thus, the end() iterator (which is valid, but is not dereferenceable) cannot be used as a value for pos.
If called on a primitive type other than null, the resulting JSON value will be null.
Remove an element range specified by [first; last) from a JSON value. The iterator first does not need to be dereferenceable if first == last: erasing an empty range is a no-op.
If called on a primitive type other than null, the resulting JSON value will be null.
Removes an element from a JSON object by key.
See 3. This overload is only available if KeyType is comparable with typename object_t::key_type and typename object_comparator_t::is_transparent denotes a type.
Removes an element from a JSON array by index.
KeyType A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17)."},{"location":"api/basic_json/erase/#parameters","title":"Parameters","text":"pos (in) iterator to the element to remove first (in) iterator to the beginning of the range to remove last (in) iterator past the end of the range to remove key (in) object key of the elements to remove idx (in) array index of the element to remove"},{"location":"api/basic_json/erase/#return-value","title":"Return value","text":"pos refers to the last element, the end() iterator is returned.last refers to the last element, the end() iterator is returned.ObjectType is the default std::map type, the return value will always be 0 (key was not found) or 1 (key was found).Strong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/erase/#exceptions","title":"Exceptions","text":"type_error.307 if called on a null value; example: \"cannot use erase() with null\"invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: \"iterator does not fit current value\"invalid_iterator.205 if called on a primitive type with invalid iterator (i.e., any iterator which is not begin()); example: \"iterator out of range\"type_error.307 if called on a null value; example: \"cannot use erase() with null\"invalid_iterator.203 if called on iterators which does not belong to the current JSON value; example: \"iterators do not fit current value\"invalid_iterator.204 if called on a primitive type with invalid iterators (i.e., if first != begin() and last != end()); example: \"iterators out of range\"type_error.307 when called on a type other than JSON object; example: \"cannot use erase() with null\"type_error.307 when called on a type other than JSON array; example: \"cannot use erase() with null\"out_of_range.401 when idx >= size(); example: \"array index 17 is out of range\"pos and the end of the containerlog(size()) + std::distance(first, last)first and last, plus linear in the distance between last and end of the containerlog(size()) + count(key)log(size()) + count(key)idx and the end of the container.erase, including the end() iterator.The example shows the effect of erase() for different JSON types using an iterator.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n\n // call erase()\n j_boolean.erase(j_boolean.begin());\n j_number_integer.erase(j_number_integer.begin());\n j_number_float.erase(j_number_float.begin());\n j_object.erase(j_object.find(\"two\"));\n j_array.erase(j_array.begin() + 2);\n j_string.erase(j_string.begin());\n\n // print values\n std::cout << j_boolean << '\\n';\n std::cout << j_number_integer << '\\n';\n std::cout << j_number_float << '\\n';\n std::cout << j_object << '\\n';\n std::cout << j_array << '\\n';\n std::cout << j_string << '\\n';\n}\nOutput:
null\nnull\nnull\n{\"one\":1}\n[1,2,8,16]\nnull\nThe example shows the effect of erase() for different JSON types using an iterator range.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n\n // call erase()\n j_boolean.erase(j_boolean.begin(), j_boolean.end());\n j_number_integer.erase(j_number_integer.begin(), j_number_integer.end());\n j_number_float.erase(j_number_float.begin(), j_number_float.end());\n j_object.erase(j_object.find(\"two\"), j_object.end());\n j_array.erase(j_array.begin() + 1, j_array.begin() + 3);\n j_string.erase(j_string.begin(), j_string.end());\n\n // print values\n std::cout << j_boolean << '\\n';\n std::cout << j_number_integer << '\\n';\n std::cout << j_number_float << '\\n';\n std::cout << j_object << '\\n';\n std::cout << j_array << '\\n';\n std::cout << j_string << '\\n';\n}\nOutput:
null\nnull\nnull\n{\"one\":1}\n[1,8,16]\nnull\nThe example shows the effect of erase() for different JSON types using an object key.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n\n // call erase()\n auto count_one = j_object.erase(\"one\");\n auto count_three = j_object.erase(\"three\");\n\n // print values\n std::cout << j_object << '\\n';\n std::cout << count_one << \" \" << count_three << '\\n';\n}\nOutput:
{\"two\":2}\n1 0\nThe example shows the effect of erase() for different JSON types using an object key.
#include <iostream>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n\n // call erase()\n auto count_one = j_object.erase(\"one\"sv);\n auto count_three = j_object.erase(\"three\"sv);\n\n // print values\n std::cout << j_object << '\\n';\n std::cout << count_one << \" \" << count_three << '\\n';\n}\nOutput:
{\"two\":2}\n1 0\nThe example shows the effect of erase() using an array index.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON array\n json j_array = {0, 1, 2, 3, 4, 5};\n\n // call erase()\n j_array.erase(2);\n\n // print values\n std::cout << j_array << '\\n';\n}\nOutput:
[0,1,3,4,5]\nenum class error_handler_t {\n strict,\n replace,\n ignore\n};\nThis enumeration is used in the dump function to choose how to treat decoding errors while serializing a basic_json value. Three values are differentiated:
type_error exception in case of invalid UTF-8 replace replace invalid UTF-8 sequences with U+FFFD (\ufffd REPLACEMENT CHARACTER) ignore ignore invalid UTF-8 sequences; all valid bytes are copied to the output unchanged, and invalid bytes are dropped"},{"location":"api/basic_json/error_handler_t/#examples","title":"Examples","text":"Example The example below shows how the different values of the error_handler_t influence the behavior of dump when reading serializing an invalid UTF-8 sequence.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON value with invalid UTF-8 byte sequence\n json j_invalid = \"\u00e4\\xA9\u00fc\";\n try\n {\n std::cout << j_invalid.dump() << std::endl;\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n std::cout << \"string with replaced invalid characters: \"\n << j_invalid.dump(-1, ' ', false, json::error_handler_t::replace)\n << \"\\nstring with ignored invalid characters: \"\n << j_invalid.dump(-1, ' ', false, json::error_handler_t::ignore)\n << '\\n';\n}\nOutput:
[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9\nstring with replaced invalid characters: \"\u00e4\ufffd\u00fc\"\nstring with ignored invalid characters: \"\u00e4\u00fc\"\nclass exception : public std::exception;\nThis class is an extension of std::exception objects with a member id for exception ids. It is used as the base class for all exceptions thrown by the basic_json class. This class can hence be used as \"wildcard\" to catch exceptions, see example below.
classDiagram\n direction LR\n\n class std_exception [\"std::exception\"] {\n <<interface>>\n }\n\n class json_exception [\"basic_json::exception\"] {\n +const int id\n +const char* what() const\n }\n\n class json_parse_error [\"basic_json::parse_error\"] {\n +const std::size_t byte\n }\n\n class json_invalid_iterator [\"basic_json::invalid_iterator\"]\n class json_type_error [\"basic_json::type_error\"]\n class json_out_of_range [\"basic_json::out_of_range\"]\n class json_other_error [\"basic_json::other_error\"]\n\n std_exception <|-- json_exception\n json_exception <|-- json_parse_error\n json_exception <|-- json_invalid_iterator\n json_exception <|-- json_type_error\n json_exception <|-- json_out_of_range\n json_exception <|-- json_other_error\n\n style json_exception fill:#CCCCFFSubclasses:
parse_error for exceptions indicating a parse errorinvalid_iterator for exceptions indicating errors with iteratorstype_error for exceptions indicating executing a member function with a wrong typeout_of_range for exceptions indicating access out of the defined rangeother_error for exceptions indicating other library errorsTo have nothrow-copy-constructible exceptions, we internally use std::runtime_error which can cope with arbitrary-length error messages. Intermediate strings are built with static functions and then passed to the actual constructor.
The following code shows how arbitrary library exceptions can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // calling at() for a non-existing key\n json j = {{\"foo\", \"bar\"}};\n json k = j.at(\"non-existing\");\n }\n catch (const json::exception& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.out_of_range.403] key 'non-existing' not found\nexception id: 403\nList of exceptions
"},{"location":"api/basic_json/exception/#version-history","title":"Version history","text":"// (1)\niterator find(const typename object_t::key_type& key);\nconst_iterator find(const typename object_t::key_type& key) const;\n\n// (2)\ntemplate<typename KeyType>\niterator find(KeyType&& key);\ntemplate<typename KeyType>\nconst_iterator find(KeyType&& key) const;\nkey. If the element is not found or the JSON value is not an object, end() is returned.KeyType is comparable with typename object_t::key_type and typename object_comparator_t::is_transparent denotes a type.KeyType A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17)."},{"location":"api/basic_json/find/#parameters","title":"Parameters","text":"key (in) key value of the element to search for."},{"location":"api/basic_json/find/#return-value","title":"Return value","text":"Iterator to an element with a key equivalent to key. If no such element is found or the JSON value is not an object, a past-the-end iterator (see end()) is returned.
Strong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/find/#complexity","title":"Complexity","text":"Logarithmic in the size of the JSON object.
"},{"location":"api/basic_json/find/#notes","title":"Notes","text":"This method always returns end() when executed on a JSON type that is not an object.
The example shows how find() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n\n // call find\n auto it_two = j_object.find(\"two\");\n auto it_three = j_object.find(\"three\");\n\n // print values\n std::cout << std::boolalpha;\n std::cout << \"\\\"two\\\" was found: \" << (it_two != j_object.end()) << '\\n';\n std::cout << \"value at key \\\"two\\\": \" << *it_two << '\\n';\n std::cout << \"\\\"three\\\" was found: \" << (it_three != j_object.end()) << '\\n';\n}\nOutput:
\"two\" was found: true\nvalue at key \"two\": 2\n\"three\" was found: false\nThe example shows how find() is used.
#include <iostream>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n\n // call find\n auto it_two = j_object.find(\"two\"sv);\n auto it_three = j_object.find(\"three\"sv);\n\n // print values\n std::cout << std::boolalpha;\n std::cout << \"\\\"two\\\" was found: \" << (it_two != j_object.end()) << '\\n';\n std::cout << \"value at key \\\"two\\\": \" << *it_two << '\\n';\n std::cout << \"\\\"three\\\" was found: \" << (it_three != j_object.end()) << '\\n';\n}\nOutput:
\"two\" was found: true\nvalue at key \"two\": 2\n\"three\" was found: false\nbasic_json flatten() const;\nThe function creates a JSON object whose keys are JSON pointers (see RFC 6901) and whose values are all primitive (see is_primitive() for more information). The original JSON value can be restored using the unflatten() function.
an object that maps JSON pointers to primitive values
"},{"location":"api/basic_json/flatten/#exception-safety","title":"Exception safety","text":"Strong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/flatten/#complexity","title":"Complexity","text":"Linear in the size of the JSON value.
"},{"location":"api/basic_json/flatten/#notes","title":"Notes","text":"Empty objects and arrays are flattened to null and will not be reconstructed correctly by the unflatten() function.
The following code shows how a JSON object is flattened to an object whose keys consist of JSON pointers.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON value\n json j =\n {\n {\"pi\", 3.141},\n {\"happy\", true},\n {\"name\", \"Niels\"},\n {\"nothing\", nullptr},\n {\n \"answer\", {\n {\"everything\", 42}\n }\n },\n {\"list\", {1, 0, 2}},\n {\n \"object\", {\n {\"currency\", \"USD\"},\n {\"value\", 42.99}\n }\n }\n };\n\n // call flatten()\n std::cout << std::setw(4) << j.flatten() << '\\n';\n}\nOutput:
{\n \"/answer/everything\": 42,\n \"/happy\": true,\n \"/list/0\": 1,\n \"/list/1\": 0,\n \"/list/2\": 2,\n \"/name\": \"Niels\",\n \"/nothing\": null,\n \"/object/currency\": \"USD\",\n \"/object/value\": 42.99,\n \"/pi\": 3.141\n}\ntemplate <typename BasicJsonType>\nstd::string format_as(const BasicJsonType& j);\nThis function implements the format_as customization point used by the {fmt} library (fmtlib). It has no dependency on any fmt header and no effect at all unless a caller's translation unit also includes fmt and calls fmt::format/fmt::print on a JSON value.
BasicJsonType a specialization of basic_json"},{"location":"api/basic_json/format_as/#return-value","title":"Return value","text":"string containing the serialization of the JSON value (same as dump())
Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
"},{"location":"api/basic_json/format_as/#exceptions","title":"Exceptions","text":"Throws type_error.316 if a string stored inside the JSON value is not UTF-8 encoded
Linear.
"},{"location":"api/basic_json/format_as/#possible-implementation","title":"Possible implementation","text":"template <typename BasicJsonType>\nstd::string format_as(const BasicJsonType& j)\n{\n return j.dump();\n}\nVersion-dependent effect on fmt
fmt only picks up a format_as overload that returns a std::string in fmt 10.0.0 through 11.0.2. Starting with fmt 11.1.0, fmt restricts automatic format_as pickup to overloads that return an arithmetic type, so this function has no effect there (it is simply unused, not a compile error).
If you use fmt >= 11.1.0, or want the same pretty-print spec support that std::formatter<basic_json> has (\"{:#}\", a width to set the indent such as \"{:2}\"/\"{:#2}\", and fill-and-align to pick the indent character such as \"{:.>#}\"), define your own fmt::formatter specialization mirroring the same logic:
template <>\nstruct fmt::formatter<nlohmann::json>\n{\n // -1 means compact output (dump()); any value >= 0 means pretty-printed\n // output with that many spaces (or indent_char) per level.\n int indent = -1;\n char indent_char = ' ';\n\n constexpr auto parse(format_parse_context& ctx) -> format_parse_context::iterator\n {\n auto it = ctx.begin();\n const auto end = ctx.end();\n constexpr auto is_align = [](char c)\n {\n return c == '<' || c == '>' || c == '^';\n };\n\n // [[fill] align] - repurposed here to pick a custom indent character\n if (it != end && it + 1 != end && is_align(it[1]))\n {\n indent_char = *it;\n it += 2;\n }\n else if (it != end && is_align(*it))\n {\n ++it;\n }\n\n // ['#'] - \"alternate form\", used here to request pretty-printing with a\n // default indent of 4 (overridden by an explicit width below, if given)\n if (it != end && *it == '#')\n {\n indent = 4;\n ++it;\n }\n\n // [width] - repurposed here to pick the indent size; a width without '#'\n // implies pretty-printing since an indent otherwise has no meaning\n if (it != end && *it >= '1' && *it <= '9')\n {\n indent = 0;\n while (it != end && *it >= '0' && *it <= '9')\n {\n indent = (indent * 10) + (*it - '0');\n ++it;\n }\n }\n\n if (it != end && *it != '}')\n {\n throw fmt::format_error(\"invalid format args for nlohmann::json\");\n }\n\n return it;\n }\n\n auto format(const nlohmann::json& j, format_context& ctx) const\n {\n const auto dumped = j.dump(indent, indent_char);\n return fmt::format_to(ctx.out(), \"{}\", dumped);\n }\n};\nThis recipe isn't shipped by the library itself, since doing so would make fmt a build dependency (see the FAQ entry on using JSON values with std::format or fmt for more background) \u2014 but it is compiled and exercised against a real, current fmt release as part of the library's own test suite (tests/fmt_formatter, via CMake FetchContent), so it's kept in sync with std::formatter<basic_json> and verified to actually work, not just illustrative.
The following code shows how the library's format_as() function integrates with fmt::format, allowing argument-dependent lookup.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value\n json j = {{\"one\", 1}, {\"two\", 2}};\n\n // format_as() is found via argument-dependent lookup, the same way\n // fmt::format/fmt::print would find it\n auto j_str = format_as(j);\n\n std::cout << j_str << std::endl;\n}\nOutput:
{\"one\":1,\"two\":2}\nstd::format (C++20) equivalent // (1)\ntemplate<typename InputType>\nstatic basic_json from_bjdata(InputType&& i,\n const bool strict = true,\n const bool allow_exceptions = true);\n// (2)\ntemplate<typename IteratorType>\nstatic basic_json from_bjdata(IteratorType first, IteratorType last,\n const bool strict = true,\n const bool allow_exceptions = true);\nDeserializes a given input to a JSON value using the BJData (Binary JData) serialization format.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/from_bjdata/#template-parameters","title":"Template parameters","text":"InputType A compatible input, for instance:
std::istream objectFILE pointerobj for which begin(obj) and end(obj) produces a valid pair of iterators.IteratorType a compatible iterator type"},{"location":"api/basic_json/from_bjdata/#parameters","title":"Parameters","text":"i (in) an input in BJData format convertible to an input adapter first (in) iterator to the start of the input last (in) iterator to the end of the input strict (in) whether to expect the input to be consumed until EOF (true by default) allow_exceptions (in) whether to throw exceptions in case of a parse error (optional, true by default)"},{"location":"api/basic_json/from_bjdata/#return-value","title":"Return value","text":"deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/from_bjdata/#exceptions","title":"Exceptions","text":"strict was set to truestd::size_tLinear in the size of the input.
"},{"location":"api/basic_json/from_bjdata/#examples","title":"Examples","text":"ExampleThe example shows the deserialization of a byte vector in BJData format to a JSON value.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0x7B, 0x69, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x61,\n 0x63, 0x74, 0x54, 0x69, 0x06, 0x73, 0x63, 0x68,\n 0x65, 0x6D, 0x61, 0x69, 0x00, 0x7D\n };\n\n // deserialize it with BJData\n json j = json::from_bjdata(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\n// (1)\ntemplate<typename InputType>\nstatic basic_json from_bson(InputType&& i,\n const bool strict = true,\n const bool allow_exceptions = true);\n// (2)\ntemplate<typename IteratorType>\nstatic basic_json from_bson(IteratorType first, IteratorType last,\n const bool strict = true,\n const bool allow_exceptions = true);\nDeserializes a given input to a JSON value using the BSON (Binary JSON) serialization format.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/from_bson/#template-parameters","title":"Template parameters","text":"InputType A compatible input, for instance:
std::istream objectFILE pointerobj for which begin(obj) and end(obj) produces a valid pair of iterators.IteratorType a compatible iterator type"},{"location":"api/basic_json/from_bson/#parameters","title":"Parameters","text":"i (in) an input in BSON format convertible to an input adapter first (in) iterator to the start of the input last (in) iterator to the end of the input strict (in) whether to expect the input to be consumed until EOF (true by default) allow_exceptions (in) whether to throw exceptions in case of a parse error (optional, true by default)"},{"location":"api/basic_json/from_bson/#return-value","title":"Return value","text":"deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/from_bson/#exceptions","title":"Exceptions","text":"parse_error.110 if the given input ends prematurely or the end of the input was not reached when strict was set to trueparse_error.112 if a parse error occurs (e.g., an invalid string or byte array length)parse_error.114 if an unsupported BSON record type is encounteredLinear in the size of the input.
"},{"location":"api/basic_json/from_bson/#examples","title":"Examples","text":"ExampleThe example shows the deserialization of a byte vector in BSON format to a JSON value.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0x1b, 0x00, 0x00, 0x00, 0x08, 0x63, 0x6f, 0x6d,\n 0x70, 0x61, 0x63, 0x74, 0x00, 0x01, 0x10, 0x73,\n 0x63, 0x68, 0x65, 0x6d, 0x61, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00\n };\n\n // deserialize it with BSON\n json j = json::from_bson(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nDeprecation
from_bson with a pointer and a length as first two parameters, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_bson(ptr, len, ...); with from_bson(ptr, ptr+len, ...);.from_bson with a pair of iterators as their first parameter, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_bson({ptr, ptr+len}, ...); with from_bson(ptr, ptr+len, ...);.You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
// (1)\ntemplate<typename InputType>\nstatic basic_json from_cbor(InputType&& i,\n const bool strict = true,\n const bool allow_exceptions = true,\n const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error);\n\n// (2)\ntemplate<typename IteratorType>\nstatic basic_json from_cbor(IteratorType first, IteratorType last,\n const bool strict = true,\n const bool allow_exceptions = true,\n const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error);\nDeserializes a given input to a JSON value using the CBOR (Concise Binary Object Representation) serialization format.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/from_cbor/#template-parameters","title":"Template parameters","text":"InputType A compatible input, for instance:
std::istream objectFILE pointerobj for which begin(obj) and end(obj) produces a valid pair of iterators.IteratorType a compatible iterator type"},{"location":"api/basic_json/from_cbor/#parameters","title":"Parameters","text":"i (in) an input in CBOR format convertible to an input adapter first (in) iterator to the start of the input last (in) iterator to the end of the input strict (in) whether to expect the input to be consumed until EOF (true by default) allow_exceptions (in) whether to throw exceptions in case of a parse error (optional, true by default) tag_handler (in) how to treat CBOR tags (optional, error by default); see cbor_tag_handler_t for more information"},{"location":"api/basic_json/from_cbor/#return-value","title":"Return value","text":"deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/from_cbor/#exceptions","title":"Exceptions","text":"strict was set to trueLinear in the size of the input.
"},{"location":"api/basic_json/from_cbor/#examples","title":"Examples","text":"ExampleThe example shows the deserialization of a byte vector in CBOR format to a JSON value.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0xa2, 0x67, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63,\n 0x74, 0xf5, 0x66, 0x73, 0x63, 0x68, 0x65, 0x6d,\n 0x61, 0x00\n };\n\n // deserialize it with CBOR\n json j = json::from_cbor(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nstart_index since version 2.1.1.start_index parameter, and added strict parameter in version 3.0.0.allow_exceptions parameter in version 3.2.0.tag_handler parameter in version 3.9.0.Deprecation
from_cbor with a pointer and a length as first two parameters, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_cbor(ptr, len, ...); with from_cbor(ptr, ptr+len, ...);.from_cbor with a pair of iterators as their first parameter, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_cbor({ptr, ptr+len}, ...); with from_cbor(ptr, ptr+len, ...);.You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
// (1)\ntemplate<typename InputType>\nstatic basic_json from_msgpack(InputType&& i,\n const bool strict = true,\n const bool allow_exceptions = true);\n// (2)\ntemplate<typename IteratorType>\nstatic basic_json from_msgpack(IteratorType first, IteratorType last,\n const bool strict = true,\n const bool allow_exceptions = true);\nDeserializes a given input to a JSON value using the MessagePack serialization format.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/from_msgpack/#template-parameters","title":"Template parameters","text":"InputType A compatible input, for instance:
std::istream objectFILE pointerobj for which begin(obj) and end(obj) produces a valid pair of iterators.IteratorType a compatible iterator type"},{"location":"api/basic_json/from_msgpack/#parameters","title":"Parameters","text":"i (in) an input in MessagePack format convertible to an input adapter first (in) iterator to the start of the input last (in) iterator to the end of the input strict (in) whether to expect the input to be consumed until EOF (true by default) allow_exceptions (in) whether to throw exceptions in case of a parse error (optional, true by default)"},{"location":"api/basic_json/from_msgpack/#return-value","title":"Return value","text":"deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/from_msgpack/#exceptions","title":"Exceptions","text":"strict was set to trueLinear in the size of the input.
"},{"location":"api/basic_json/from_msgpack/#examples","title":"Examples","text":"ExampleThe example shows the deserialization of a byte vector in MessagePack format to a JSON value.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0x82, 0xa7, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63,\n 0x74, 0xc3, 0xa6, 0x73, 0x63, 0x68, 0x65, 0x6d,\n 0x61, 0x00\n };\n\n // deserialize it with MessagePack\n json j = json::from_msgpack(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nstart_index since version 2.1.1.start_index parameter, and added strict parameter in version 3.0.0.allow_exceptions parameter in version 3.2.0.Deprecation
from_msgpack with a pointer and a length as first two parameters, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_msgpack(ptr, len, ...); with from_msgpack(ptr, ptr+len, ...);.from_msgpack with a pair of iterators as their first parameter, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_msgpack({ptr, ptr+len}, ...); with from_msgpack(ptr, ptr+len, ...);.You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
// (1)\ntemplate<typename InputType>\nstatic basic_json from_ubjson(InputType&& i,\n const bool strict = true,\n const bool allow_exceptions = true);\n// (2)\ntemplate<typename IteratorType>\nstatic basic_json from_ubjson(IteratorType first, IteratorType last,\n const bool strict = true,\n const bool allow_exceptions = true);\nDeserializes a given input to a JSON value using the UBJSON (Universal Binary JSON) serialization format.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/from_ubjson/#template-parameters","title":"Template parameters","text":"InputType A compatible input, for instance:
std::istream objectFILE pointerobj for which begin(obj) and end(obj) produces a valid pair of iterators.IteratorType a compatible iterator type"},{"location":"api/basic_json/from_ubjson/#parameters","title":"Parameters","text":"i (in) an input in UBJSON format convertible to an input adapter first (in) iterator to the start of the input last (in) iterator to the end of the input strict (in) whether to expect the input to be consumed until EOF (true by default) allow_exceptions (in) whether to throw exceptions in case of a parse error (optional, true by default)"},{"location":"api/basic_json/from_ubjson/#return-value","title":"Return value","text":"deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/from_ubjson/#exceptions","title":"Exceptions","text":"strict was set to truestd::size_tLinear in the size of the input.
"},{"location":"api/basic_json/from_ubjson/#examples","title":"Examples","text":"ExampleThe example shows the deserialization of a byte vector in UBJSON format to a JSON value.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0x7B, 0x69, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x61,\n 0x63, 0x74, 0x54, 0x69, 0x06, 0x73, 0x63, 0x68,\n 0x65, 0x6D, 0x61, 0x69, 0x00, 0x7D\n };\n\n // deserialize it with UBJSON\n json j = json::from_ubjson(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nallow_exceptions parameter in version 3.2.0.Deprecation
from_ubjson with a pointer and a length as first two parameters, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_ubjson(ptr, len, ...); with from_ubjson(ptr, ptr+len, ...);.from_ubjson with a pair of iterators as their first parameter, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_ubjson({ptr, ptr+len}, ...); with from_ubjson(ptr, ptr+len, ...);.You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
reference front();\nconst_reference front() const;\nReturns a reference to the first element in the container. For a JSON container c, the expression c.front() is equivalent to *c.begin().
In the case of a structured type (array or object), a reference to the first element is returned. In the case of number, string, boolean, or binary values, a reference to the value is returned.
"},{"location":"api/basic_json/front/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/front/#exceptions","title":"Exceptions","text":"If the JSON value is null, exception invalid_iterator.214 is thrown.
Constant.
"},{"location":"api/basic_json/front/#notes","title":"Notes","text":"Precondition
The array or object must not be empty. Calling front on an empty array or object yields undefined behavior.
The following code shows an example for front().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_object_empty(json::value_t::object);\n json j_array = {1, 2, 4, 8, 16};\n json j_array_empty(json::value_t::array);\n json j_string = \"Hello, world\";\n\n // call front()\n //std::cout << j_null.front() << '\\n'; // would throw\n std::cout << j_boolean.front() << '\\n';\n std::cout << j_number_integer.front() << '\\n';\n std::cout << j_number_float.front() << '\\n';\n std::cout << j_object.front() << '\\n';\n //std::cout << j_object_empty.front() << '\\n'; // undefined behavior\n std::cout << j_array.front() << '\\n';\n //std::cout << j_array_empty.front() << '\\n'; // undefined behavior\n std::cout << j_string.front() << '\\n';\n}\nOutput:
true\n17\n23.42\n1\n1\n\"Hello, world\"\n// (1)\ntemplate<typename ValueType>\nValueType get() const noexcept(\n noexcept(JSONSerializer<ValueType>::from_json(\n std::declval<const basic_json_t&>(), std::declval<ValueType&>())));\n\n// (2)\ntemplate<typename BasicJsonType>\nBasicJsonType get() const;\n\n// (3)\ntemplate<typename PointerType>\nPointerType get_ptr();\n\ntemplate<typename PointerType>\nconstexpr const PointerType get_ptr() const noexcept;\nExplicit type conversion between the JSON value and a compatible value which is CopyConstructible and DefaultConstructible. The value is converted by calling the json_serializer<ValueType> from_json() method.
The function is equivalent to executing
ValueType ret;\nJSONSerializer<ValueType>::from_json(*this, ret);\nreturn ret;\nThis overload is chosen if:
ValueType is not basic_json,json_serializer<ValueType> has a from_json() method of the form void from_json(const basic_json&, ValueType&), andjson_serializer<ValueType> does not have a from_json() method of the form ValueType from_json(const basic_json&)If the type is not CopyConstructible and not DefaultConstructible, the value is converted by calling the json_serializer<ValueType> from_json() method.
The function is then equivalent to executing
return JSONSerializer<ValueTypeCV>::from_json(*this);\nThis overload is chosen if:
ValueType is not basic_json andjson_serializer<ValueType> has a from_json() method of the form ValueType from_json(const basic_json&)If json_serializer<ValueType> has both overloads of from_json(), the latter one is chosen.
Overload for basic_json specializations. The function is equivalent to executing
return *this;\nExplicit pointer access to the internally stored JSON value. No copies are made.
ValueType the value type to return BasicJsonType a specialization of basic_json PointerType pointer type; must be a pointer to array_t, object_t, string_t, boolean_t, number_integer_t, or number_unsigned_t, number_float_t, or binary_t. Other types will not compile."},{"location":"api/basic_json/get/#return-value","title":"Return value","text":"ValueType*this, converted into BasicJsonTypenullptr otherwiseDepends on what json_serializer<ValueType> from_json() method throws
Depends on the json_serializer<ValueType>::from_json() implementation for overloads (1) and (2); constant for overload (3).
Undefined behavior for pointers
Writing data to the pointee (overload 3) of the result yields an undefined state.
Undefined behavior for numeric conversions
Conversions between numeric types are performed by the corresponding from_json() implementation using the target C++ type. When converting between numeric types, the library does not check whether the source value is representable by the target type.
If the source value is outside the range of the target type, the behavior is the same as the corresponding C++ conversion. In particular, converting a floating-point value to an integer type that cannot represent the value results in undefined behavior.
See Number conversion for more information.
"},{"location":"api/basic_json/get/#examples","title":"Examples","text":"ExampleThe example below shows several conversions from JSON values to other types. There a few things to note: (1) Floating-point numbers can be converted to integers, (2) A JSON array can be converted to a standard std::vector<short>, (3) A JSON object can be converted to C++ associative containers such as std::unordered_map<std::string, json>.
#include <iostream>\n#include <unordered_map>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value with different types\n json json_types =\n {\n {\"boolean\", true},\n {\n \"number\", {\n {\"integer\", 42},\n {\"floating-point\", 17.23}\n }\n },\n {\"string\", \"Hello, world!\"},\n {\"array\", {1, 2, 3, 4, 5}},\n {\"null\", nullptr}\n };\n\n // use explicit conversions\n auto v1 = json_types[\"boolean\"].get<bool>();\n auto v2 = json_types[\"number\"][\"integer\"].get<int>();\n auto v3 = json_types[\"number\"][\"integer\"].get<short>();\n auto v4 = json_types[\"number\"][\"floating-point\"].get<float>();\n auto v5 = json_types[\"number\"][\"floating-point\"].get<int>();\n auto v6 = json_types[\"string\"].get<std::string>();\n auto v7 = json_types[\"array\"].get<std::vector<short>>();\n auto v8 = json_types.get<std::unordered_map<std::string, json>>();\n\n // print the conversion results\n std::cout << v1 << '\\n';\n std::cout << v2 << ' ' << v3 << '\\n';\n std::cout << v4 << ' ' << v5 << '\\n';\n std::cout << v6 << '\\n';\n\n for (auto i : v7)\n {\n std::cout << i << ' ';\n }\n std::cout << \"\\n\\n\";\n\n for (auto i : v8)\n {\n std::cout << i.first << \": \" << i.second << '\\n';\n }\n}\nOutput:
1\n42 42\n17.23 17\nHello, world!\n1 2 3 4 5 \n\nstring: \"Hello, world!\"\nnumber: {\"floating-point\":17.23,\"integer\":42}\nnull: null\nboolean: true\narray: [1,2,3,4,5]\nThe example below shows how pointers to internal values of a JSON value can be requested. Note that no type conversions are made and a #cpp nullptr is returned if the value and the requested pointer type does not match.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON number\n json value = 17;\n\n // explicitly getting pointers\n auto p1 = value.get<const json::number_integer_t*>();\n auto p2 = value.get<json::number_integer_t*>();\n auto p3 = value.get<json::number_integer_t* const>();\n auto p4 = value.get<const json::number_integer_t* const>();\n auto p5 = value.get<json::number_float_t*>();\n\n // print the pointees\n std::cout << *p1 << ' ' << *p2 << ' ' << *p3 << ' ' << *p4 << '\\n';\n std::cout << std::boolalpha << (p5 == nullptr) << '\\n';\n}\nOutput:
17 17 17 17\ntrue\nbasic_json in version 3.2.0.static allocator_type get_allocator();\nReturns the allocator associated with the container.
"},{"location":"api/basic_json/get_allocator/#return-value","title":"Return value","text":"associated allocator
"},{"location":"api/basic_json/get_allocator/#examples","title":"Examples","text":"ExampleThe example shows how get_allocator() is used to created json values.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n auto alloc = json::get_allocator();\n using traits_t = std::allocator_traits<decltype(alloc)>;\n\n json* j = traits_t::allocate(alloc, 1);\n traits_t::construct(alloc, j, \"Hello, world!\");\n\n std::cout << *j << std::endl;\n\n traits_t::destroy(alloc, j);\n traits_t::deallocate(alloc, j, 1);\n}\nOutput:
\"Hello, world!\"\nbinary_t& get_binary();\n\nconst binary_t& get_binary() const;\nReturns a reference to the stored binary value.
"},{"location":"api/basic_json/get_binary/#return-value","title":"Return value","text":"Reference to binary value.
"},{"location":"api/basic_json/get_binary/#exception-safety","title":"Exception safety","text":"Strong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/get_binary/#exceptions","title":"Exceptions","text":"Throws type_error.302 if the value is not binary
Constant.
"},{"location":"api/basic_json/get_binary/#examples","title":"Examples","text":"ExampleThe following code shows how to query a binary value.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a binary vector\n std::vector<std::uint8_t> vec = {0xCA, 0xFE, 0xBA, 0xBE};\n\n // create a binary JSON value with subtype 42\n json j = json::binary(vec, 42);\n\n // output type and subtype\n std::cout << \"type: \" << j.type_name() << \", subtype: \" << j.get_binary().subtype() << std::endl;\n}\nOutput:
type: binary, subtype: 42\ntemplate<typename PointerType>\nPointerType get_ptr() noexcept;\n\ntemplate<typename PointerType>\nconstexpr const PointerType get_ptr() const noexcept;\nImplicit pointer access to the internally stored JSON value. No copies are made.
"},{"location":"api/basic_json/get_ptr/#template-parameters","title":"Template parameters","text":"PointerType pointer type; must be a pointer to array_t, object_t, string_t, boolean_t, number_integer_t, or number_unsigned_t, number_float_t, or binary_t. Other types will not compile."},{"location":"api/basic_json/get_ptr/#return-value","title":"Return value","text":"pointer to the internally stored JSON value if the requested pointer type fits to the JSON value; nullptr otherwise
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/get_ptr/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/get_ptr/#notes","title":"Notes","text":"Undefined behavior
The pointer becomes invalid if the underlying JSON object changes.
Consider the following example code where the pointer ptr changes after the array is resized. As a result, reading or writing to ptr after the array change would be undefined behavior. The address of the first array element changes, because the underlying std::vector is resized after adding a fifth element.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j = {1, 2, 3, 4};\n auto* ptr = j[0].get_ptr<std::int64_t*>();\n std::cout << \"value at \" << ptr << \" is \" << *ptr << std::endl;\n\n j.push_back(5);\n\n ptr = j[0].get_ptr<std::int64_t*>();\n std::cout << \"value at \" << ptr << \" is \" << *ptr << std::endl;\n}\nOutput:
value at 0x6000012fc1c8 is 1\nvalue at 0x6000029fc088 is 1\nThe example below shows how pointers to internal values of a JSON value can be requested. Note that no type conversions are made and a nullptr is returned if the value and the requested pointer type does not match.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON number\n json value = 17;\n\n // explicitly getting pointers\n auto p1 = value.get_ptr<const json::number_integer_t*>();\n auto p2 = value.get_ptr<json::number_integer_t*>();\n auto p3 = value.get_ptr<json::number_integer_t* const>();\n auto p4 = value.get_ptr<const json::number_integer_t* const>();\n auto p5 = value.get_ptr<json::number_float_t*>();\n\n // print the pointees\n std::cout << *p1 << ' ' << *p2 << ' ' << *p3 << ' ' << *p4 << '\\n';\n std::cout << std::boolalpha << (p5 == nullptr) << '\\n';\n}\nOutput:
17 17 17 17\ntrue\ntemplate<typename ReferenceType>\nReferenceType get_ref();\n\ntemplate<typename ReferenceType>\nconst ReferenceType get_ref() const;\nImplicit reference access to the internally stored JSON value. No copies are made.
"},{"location":"api/basic_json/get_ref/#template-parameters","title":"Template parameters","text":"ReferenceType reference type; must be a reference to array_t, object_t, string_t, boolean_t, number_integer_t, or number_unsigned_t, number_float_t, or binary_t. Enforced by a static assertion."},{"location":"api/basic_json/get_ref/#return-value","title":"Return value","text":"reference to the internally stored JSON value if the requested reference type fits to the JSON value; throws type_error.303 otherwise
Strong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/get_ref/#exceptions","title":"Exceptions","text":"Throws type_error.303 if the requested reference type does not match the stored JSON value type; example: \"incompatible ReferenceType for get_ref, actual type is binary\".
Constant.
"},{"location":"api/basic_json/get_ref/#notes","title":"Notes","text":"Undefined behavior
The reference becomes invalid if the underlying JSON object changes.
"},{"location":"api/basic_json/get_ref/#examples","title":"Examples","text":"ExampleThe example shows several calls to get_ref().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON number\n json value = 17;\n\n // explicitly getting references\n auto r1 = value.get_ref<const json::number_integer_t&>();\n auto r2 = value.get_ref<json::number_integer_t&>();\n\n // print the values\n std::cout << r1 << ' ' << r2 << '\\n';\n\n // incompatible type throws exception\n try\n {\n auto r3 = value.get_ref<json::number_float_t&>();\n }\n catch (const json::type_error& ex)\n {\n std::cout << ex.what() << '\\n';\n }\n}\nOutput:
17 17\n[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number\ntemplate<typename ValueType>\nValueType& get_to(ValueType& v) const noexcept(\n noexcept(JSONSerializer<ValueType>::from_json(\n std::declval<const basic_json_t&>(), v)));\nExplicit type conversion between the JSON value and a compatible value. The value is filled into the input parameter by calling the json_serializer<ValueType> from_json() method.
The function is equivalent to executing
ValueType v;\nJSONSerializer<ValueType>::from_json(*this, v);\nThis overload is chosen if:
ValueType is not basic_json,json_serializer<ValueType> has a from_json() method of the form void from_json(const basic_json&, ValueType&)ValueType the value type to return"},{"location":"api/basic_json/get_to/#return-value","title":"Return value","text":"the input parameter, allowing chaining calls
"},{"location":"api/basic_json/get_to/#exceptions","title":"Exceptions","text":"Depends on what json_serializer<ValueType> from_json() method throws
Depends on the json_serializer<ValueType>::from_json() implementation.
The example below shows several conversions from JSON values to other types. There a few things to note: (1) Floating-point numbers can be converted to integers, (2) A JSON array can be converted to a standard std::vector<short>, (3) A JSON object can be converted to C++ associative containers such as #cpp std::unordered_map<std::string, json>.
#include <iostream>\n#include <unordered_map>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value with different types\n json json_types =\n {\n {\"boolean\", true},\n {\n \"number\", {\n {\"integer\", 42},\n {\"floating-point\", 17.23}\n }\n },\n {\"string\", \"Hello, world!\"},\n {\"array\", {1, 2, 3, 4, 5}},\n {\"null\", nullptr}\n };\n\n bool v1;\n int v2;\n short v3;\n float v4;\n int v5;\n std::string v6;\n std::vector<short> v7;\n std::unordered_map<std::string, json> v8;\n\n // use explicit conversions\n json_types[\"boolean\"].get_to(v1);\n json_types[\"number\"][\"integer\"].get_to(v2);\n json_types[\"number\"][\"integer\"].get_to(v3);\n json_types[\"number\"][\"floating-point\"].get_to(v4);\n json_types[\"number\"][\"floating-point\"].get_to(v5);\n json_types[\"string\"].get_to(v6);\n json_types[\"array\"].get_to(v7);\n json_types.get_to(v8);\n\n // print the conversion results\n std::cout << v1 << '\\n';\n std::cout << v2 << ' ' << v3 << '\\n';\n std::cout << v4 << ' ' << v5 << '\\n';\n std::cout << v6 << '\\n';\n\n for (auto i : v7)\n {\n std::cout << i << ' ';\n }\n std::cout << \"\\n\\n\";\n\n for (auto i : v8)\n {\n std::cout << i.first << \": \" << i.second << '\\n';\n }\n}\nOutput:
1\n42 42\n17.23 17\nHello, world!\n1 2 3 4 5 \n\nstring: \"Hello, world!\"\nnumber: {\"floating-point\":17.23,\"integer\":42}\nnull: null\nboolean: true\narray: [1,2,3,4,5]\nenum class input_format_t {\n json,\n cbor,\n msgpack,\n ubjson,\n bson,\n bjdata\n};\nThis enumeration is used in the sax_parse function to choose the input format to parse:
The example below shows how an input_format_t enum value is passed to sax_parse to set the input format to CBOR.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // CBOR byte string\n std::vector<std::uint8_t> vec = {{0x44, 0xcA, 0xfe, 0xba, 0xbe}};\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse CBOR\n bool result = json::sax_parse(vec, &sec, json::input_format_t::cbor);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
binary(val=[...])\n\nresult: true\n// (1)\niterator insert(const_iterator pos, const basic_json& val);\niterator insert(const_iterator pos, basic_json&& val);\n\n// (2)\niterator insert(const_iterator pos, size_type cnt, const basic_json& val);\n\n// (3)\niterator insert(const_iterator pos, const_iterator first, const_iterator last);\n\n// (4)\niterator insert(const_iterator pos, initializer_list_t ilist);\n\n// (5)\nvoid insert(const_iterator first, const_iterator last);\nval into an array before iterator pos.cnt copies of val into an array before iterator pos.[first, last) into an array before iterator pos.ilist into an array before iterator pos.[first, last) into an object.For all cases where an element is added to an array, a reallocation can happen, in which case all iterators (including the end() iterator) and all references to the elements are invalidated. Otherwise, only the end() iterator is invalidated. Also, any iterator or reference after the insertion point will point to the same index, which is now a different value.
For ordered_json, also adding an element to an object can yield a reallocation which again invalidates all iterators and all references. Also, any iterator or reference after the insertion point will point to the same index, which is now a different value.
pos (in) iterator before which the content will be inserted; may be the end() iterator val (in) value to insert cnt (in) number of copies of val to insert first (in) the start of the range of elements to insert last (in) the end of the range of elements to insert ilist (in) initializer list to insert the values from"},{"location":"api/basic_json/insert/#return-value","title":"Return value","text":"val.pos if cnt==0pos if first==lastpos if ilist is emptyStrong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/insert/#exceptions","title":"Exceptions","text":"type_error.309 if called on JSON values other than arrays; example: \"cannot use insert() with string\"invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: \"iterator does not fit current value\"type_error.309 if called on JSON values other than arrays; example: \"cannot use insert() with string\"invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: \"iterator does not fit current value\"type_error.309 if called on JSON values other than arrays; example: \"cannot use insert() with string\"invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: \"iterator does not fit current value\"invalid_iterator.210 if first and last do not belong to the same JSON value; example: \"iterators do not fit\"invalid_iterator.211 if first or last are iterators into container for which insert is called; example: \"passed iterators may not belong to container\"type_error.309 if called on JSON values other than arrays; example: \"cannot use insert() with string\"invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: \"iterator does not fit current value\"type_error.309 if called on JSON values other than objects; example: \"cannot use insert() with string\"invalid_iterator.202 if first or last do not point to an object; example: \"iterators first and last must point to objects\"invalid_iterator.210 if first and last do not belong to the same JSON value; example: \"iterators do not fit\"pos and end of the container.cnt plus linear in the distance between pos and end of the container.std::distance(first, last) plus linear in the distance between pos and end of the container.ilist.size() plus linear in the distance between pos and end of the container.O(N*log(size() + N)), where N is the number of elements to insert.The example shows how insert() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON array\n json v = {1, 2, 3, 4};\n\n // insert number 10 before number 3\n auto new_pos = v.insert(v.begin() + 2, 10);\n\n // output new array and result of insert call\n std::cout << *new_pos << '\\n';\n std::cout << v << '\\n';\n}\nOutput:
10\n[1,2,10,3,4]\nThe example shows how insert() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON array\n json v = {1, 2, 3, 4};\n\n // insert number 7 copies of number 7 before number 3\n auto new_pos = v.insert(v.begin() + 2, 7, 7);\n\n // output new array and result of insert call\n std::cout << *new_pos << '\\n';\n std::cout << v << '\\n';\n}\nOutput:
7\n[1,2,7,7,7,7,7,7,7,3,4]\nThe example shows how insert() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON array\n json v = {1, 2, 3, 4};\n\n // create a JSON array to copy values from\n json v2 = {\"one\", \"two\", \"three\", \"four\"};\n\n // insert range from v2 before the end of array v\n auto new_pos = v.insert(v.end(), v2.begin(), v2.end());\n\n // output new array and result of insert call\n std::cout << *new_pos << '\\n';\n std::cout << v << '\\n';\n}\nOutput:
\"one\"\n[1,2,3,4,\"one\",\"two\",\"three\",\"four\"]\nThe example shows how insert() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON array\n json v = {1, 2, 3, 4};\n\n // insert range from v2 before the end of array v\n auto new_pos = v.insert(v.end(), {7, 8, 9});\n\n // output new array and result of insert call\n std::cout << *new_pos << '\\n';\n std::cout << v << '\\n';\n}\nOutput:
7\n[1,2,3,4,7,8,9]\nThe example shows how insert() is used.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create two JSON objects\n json j1 = {{\"one\", \"eins\"}, {\"two\", \"zwei\"}};\n json j2 = {{\"eleven\", \"elf\"}, {\"seventeen\", \"siebzehn\"}};\n\n // output objects\n std::cout << j1 << '\\n';\n std::cout << j2 << '\\n';\n\n // insert range from j2 to j1\n j1.insert(j2.begin(), j2.end());\n\n // output result of insert call\n std::cout << j1 << '\\n';\n}\nOutput:
{\"one\":\"eins\",\"two\":\"zwei\"}\n{\"eleven\":\"elf\",\"seventeen\":\"siebzehn\"}\n{\"eleven\":\"elf\",\"one\":\"eins\",\"seventeen\":\"siebzehn\",\"two\":\"zwei\"}\nclass invalid_iterator : public exception;\nThis exception is thrown if iterators passed to a library function do not match the expected semantics.
Exceptions have ids 2xx (see list of iterator errors).
classDiagram\n direction LR\n\n class std_exception [\"std::exception\"] {\n <<interface>>\n }\n\n class json_exception [\"basic_json::exception\"] {\n +const int id\n +const char* what() const\n }\n\n class json_parse_error [\"basic_json::parse_error\"] {\n +const std::size_t byte\n }\n\n class json_invalid_iterator [\"basic_json::invalid_iterator\"]\n class json_type_error [\"basic_json::type_error\"]\n class json_out_of_range [\"basic_json::out_of_range\"]\n class json_other_error [\"basic_json::other_error\"]\n\n std_exception <|-- json_exception\n json_exception <|-- json_parse_error\n json_exception <|-- json_invalid_iterator\n json_exception <|-- json_type_error\n json_exception <|-- json_out_of_range\n json_exception <|-- json_other_error\n\n style json_invalid_iterator fill:#CCCCFFThe following code shows how a invalid_iterator exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // calling iterator::key() on non-object iterator\n json j = \"string\";\n json::iterator it = j.begin();\n auto k = it.key();\n }\n catch (const json::invalid_iterator& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.invalid_iterator.207] cannot use key() for non-object iterators\nexception id: 207\nexception for the base class of all exceptions thrown by the libraryparse_error for exceptions indicating a parse errortype_error for exceptions indicating executing a member function with a wrong typeout_of_range for exceptions indicating access out of the defined rangeother_error for exceptions indicating other library errorsconstexpr bool is_array() const noexcept;\nThis function returns true if and only if the JSON value is an array.
true if type is an array, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_array/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_array/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_array() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_array()\n std::cout << std::boolalpha;\n std::cout << j_null.is_array() << '\\n';\n std::cout << j_boolean.is_array() << '\\n';\n std::cout << j_number_integer.is_array() << '\\n';\n std::cout << j_number_unsigned_integer.is_array() << '\\n';\n std::cout << j_number_float.is_array() << '\\n';\n std::cout << j_object.is_array() << '\\n';\n std::cout << j_array.is_array() << '\\n';\n std::cout << j_string.is_array() << '\\n';\n std::cout << j_binary.is_array() << '\\n';\n}\nOutput:
false\nfalse\nfalse\nfalse\nfalse\nfalse\ntrue\nfalse\nfalse\nconstexpr bool is_binary() const noexcept;\nThis function returns true if and only if the JSON value is a binary array.
true if type is binary, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_binary/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_binary/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_binary() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_binary()\n std::cout << std::boolalpha;\n std::cout << j_null.is_binary() << '\\n';\n std::cout << j_boolean.is_binary() << '\\n';\n std::cout << j_number_integer.is_binary() << '\\n';\n std::cout << j_number_unsigned_integer.is_binary() << '\\n';\n std::cout << j_number_float.is_binary() << '\\n';\n std::cout << j_object.is_binary() << '\\n';\n std::cout << j_array.is_binary() << '\\n';\n std::cout << j_string.is_binary() << '\\n';\n std::cout << j_binary.is_binary() << '\\n';\n}\nOutput:
false\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\ntrue\nconstexpr bool is_boolean() const noexcept;\nThis function returns true if and only if the JSON value is true or false.
true if type is boolean, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_boolean/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_boolean/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_boolean() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_boolean()\n std::cout << std::boolalpha;\n std::cout << j_null.is_boolean() << '\\n';\n std::cout << j_boolean.is_boolean() << '\\n';\n std::cout << j_number_integer.is_boolean() << '\\n';\n std::cout << j_number_unsigned_integer.is_boolean() << '\\n';\n std::cout << j_number_float.is_boolean() << '\\n';\n std::cout << j_object.is_boolean() << '\\n';\n std::cout << j_array.is_boolean() << '\\n';\n std::cout << j_string.is_boolean() << '\\n';\n std::cout << j_binary.is_boolean() << '\\n';\n}\nOutput:
false\ntrue\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nconstexpr bool is_discarded() const noexcept;\nThis function returns true for a JSON value if either:
parser_callback_t), orallow_exceptions set to false; see parse for more information.true if type is discarded, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_discarded/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_discarded/#notes","title":"Notes","text":"Comparisons
Discarded values are never compared equal with operator==. That is, checking whether a JSON value j is discarded will only work via:
j.is_discarded()\nbecause
j == json::value_t::discarded\nwill always be false.
Removal during parsing with callback functions
When a value is discarded by a callback function (see parser_callback_t) during parsing, then it is removed when it is part of a structured value. For instance, if the second value of an array is discarded, instead of [null, discarded, false], the array [null, false] is returned. If the top-level value itself is discarded by the callback, the parse call returns a null value.
After a successful parse, this function always returns false: discarded values can only occur during parsing and are either removed when inside a structured value or replaced by null at the top level. The exception is parsing with allow_exceptions set to false: a parse error then yields a discarded value for which this function returns true (see parse).
The following code exemplifies is_discarded() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_discarded()\n std::cout << std::boolalpha;\n std::cout << j_null.is_discarded() << '\\n';\n std::cout << j_boolean.is_discarded() << '\\n';\n std::cout << j_number_integer.is_discarded() << '\\n';\n std::cout << j_number_unsigned_integer.is_discarded() << '\\n';\n std::cout << j_number_float.is_discarded() << '\\n';\n std::cout << j_object.is_discarded() << '\\n';\n std::cout << j_array.is_discarded() << '\\n';\n std::cout << j_string.is_discarded() << '\\n';\n std::cout << j_binary.is_discarded() << '\\n';\n}\nOutput:
false\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nconstexpr bool is_null() const noexcept;\nThis function returns true if and only if the JSON value is null.
true if type is null, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_null/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_null/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_null() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_null()\n std::cout << std::boolalpha;\n std::cout << j_null.is_null() << '\\n';\n std::cout << j_boolean.is_null() << '\\n';\n std::cout << j_number_integer.is_null() << '\\n';\n std::cout << j_number_unsigned_integer.is_null() << '\\n';\n std::cout << j_number_float.is_null() << '\\n';\n std::cout << j_object.is_null() << '\\n';\n std::cout << j_array.is_null() << '\\n';\n std::cout << j_string.is_null() << '\\n';\n std::cout << j_binary.is_null() << '\\n';\n}\nOutput:
true\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\nconstexpr bool is_number() const noexcept;\nThis function returns true if and only if the JSON value is a number. This includes both integer (signed and unsigned) and floating-point values.
true if type is number (regardless whether integer, unsigned integer, or floating-point), false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_number/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_number/#possible-implementation","title":"Possible implementation","text":"constexpr bool is_number() const noexcept\n{\n return is_number_integer() || is_number_float();\n}\nThe following code exemplifies is_number() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_number()\n std::cout << std::boolalpha;\n std::cout << j_null.is_number() << '\\n';\n std::cout << j_boolean.is_number() << '\\n';\n std::cout << j_number_integer.is_number() << '\\n';\n std::cout << j_number_unsigned_integer.is_number() << '\\n';\n std::cout << j_number_float.is_number() << '\\n';\n std::cout << j_object.is_number() << '\\n';\n std::cout << j_array.is_number() << '\\n';\n std::cout << j_string.is_number() << '\\n';\n std::cout << j_binary.is_number() << '\\n';\n}\nOutput:
false\nfalse\ntrue\ntrue\ntrue\nfalse\nfalse\nfalse\nfalse\ntrue for unsigned integers in 2.0.0.constexpr bool is_number_float() const noexcept;\nThis function returns true if and only if the JSON value is a floating-point number. This excludes signed and unsigned integer values.
true if type is a floating-point number, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_number_float/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_number_float/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_number_float() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_number_float()\n std::cout << std::boolalpha;\n std::cout << j_null.is_number_float() << '\\n';\n std::cout << j_boolean.is_number_float() << '\\n';\n std::cout << j_number_integer.is_number_float() << '\\n';\n std::cout << j_number_unsigned_integer.is_number_float() << '\\n';\n std::cout << j_number_float.is_number_float() << '\\n';\n std::cout << j_object.is_number_float() << '\\n';\n std::cout << j_array.is_number_float() << '\\n';\n std::cout << j_string.is_number_float() << '\\n';\n std::cout << j_binary.is_number_float() << '\\n';\n}\nOutput:
false\nfalse\nfalse\nfalse\ntrue\nfalse\nfalse\nfalse\nfalse\nconstexpr bool is_number_integer() const noexcept;\nThis function returns true if and only if the JSON value is a signed or unsigned integer number. This excludes floating-point values.
true if type is an integer or unsigned integer number, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_number_integer/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_number_integer/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_number_integer() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_number_integer()\n std::cout << std::boolalpha;\n std::cout << j_null.is_number_integer() << '\\n';\n std::cout << j_boolean.is_number_integer() << '\\n';\n std::cout << j_number_integer.is_number_integer() << '\\n';\n std::cout << j_number_unsigned_integer.is_number_integer() << '\\n';\n std::cout << j_number_float.is_number_integer() << '\\n';\n std::cout << j_object.is_number_integer() << '\\n';\n std::cout << j_array.is_number_integer() << '\\n';\n std::cout << j_string.is_number_integer() << '\\n';\n std::cout << j_binary.is_number_integer() << '\\n';\n}\nOutput:
false\nfalse\ntrue\ntrue\nfalse\nfalse\nfalse\nfalse\nfalse\ntrue for unsigned integers in 2.0.0.constexpr bool is_number_unsigned() const noexcept;\nThis function returns true if and only if the JSON value is an unsigned integer number. This excludes floating-point and signed integer values.
true if type is an unsigned integer number, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_number_unsigned/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_number_unsigned/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_number_unsigned() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_number_unsigned()\n std::cout << std::boolalpha;\n std::cout << j_null.is_number_unsigned() << '\\n';\n std::cout << j_boolean.is_number_unsigned() << '\\n';\n std::cout << j_number_integer.is_number_unsigned() << '\\n';\n std::cout << j_number_unsigned_integer.is_number_unsigned() << '\\n';\n std::cout << j_number_float.is_number_unsigned() << '\\n';\n std::cout << j_object.is_number_unsigned() << '\\n';\n std::cout << j_array.is_number_unsigned() << '\\n';\n std::cout << j_string.is_number_unsigned() << '\\n';\n std::cout << j_binary.is_number_unsigned() << '\\n';\n}\nOutput:
false\nfalse\nfalse\ntrue\nfalse\nfalse\nfalse\nfalse\nfalse\nconstexpr bool is_object() const noexcept;\nThis function returns true if and only if the JSON value is an object.
true if type is an object, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_object/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_object/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_object() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_object()\n std::cout << std::boolalpha;\n std::cout << j_null.is_object() << '\\n';\n std::cout << j_boolean.is_object() << '\\n';\n std::cout << j_number_integer.is_object() << '\\n';\n std::cout << j_number_unsigned_integer.is_object() << '\\n';\n std::cout << j_number_float.is_object() << '\\n';\n std::cout << j_object.is_object() << '\\n';\n std::cout << j_array.is_object() << '\\n';\n std::cout << j_string.is_object() << '\\n';\n std::cout << j_binary.is_object() << '\\n';\n}\nOutput:
false\nfalse\nfalse\nfalse\nfalse\ntrue\nfalse\nfalse\nfalse\nconstexpr bool is_primitive() const noexcept;\nThis function returns true if and only if the JSON type is primitive (string, number, boolean, null, binary).
true if type is primitive (string, number, boolean, null, or binary), false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_primitive/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_primitive/#possible-implementation","title":"Possible implementation","text":"constexpr bool is_primitive() const noexcept\n{\n return is_null() || is_string() || is_boolean() || is_number() || is_binary();\n}\nThe term primitive stems from RFC 8259:
JSON can represent four primitive types (strings, numbers, booleans, and null) and two structured types (objects and arrays).
This library extends primitive types to binary types, because binary types are roughly comparable to strings. Hence, is_primitive() returns true for binary values.
The following code exemplifies is_primitive() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_primitive()\n std::cout << std::boolalpha;\n std::cout << j_null.is_primitive() << '\\n';\n std::cout << j_boolean.is_primitive() << '\\n';\n std::cout << j_number_integer.is_primitive() << '\\n';\n std::cout << j_number_unsigned_integer.is_primitive() << '\\n';\n std::cout << j_number_float.is_primitive() << '\\n';\n std::cout << j_object.is_primitive() << '\\n';\n std::cout << j_array.is_primitive() << '\\n';\n std::cout << j_string.is_primitive() << '\\n';\n std::cout << j_binary.is_primitive() << '\\n';\n}\nOutput:
true\ntrue\ntrue\ntrue\ntrue\nfalse\nfalse\ntrue\ntrue\nnulltrue for binary types in version 3.8.0.constexpr bool is_string() const noexcept;\nThis function returns true if and only if the JSON value is a string.
true if type is a string, false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_string/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_string/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_string() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_string()\n std::cout << std::boolalpha;\n std::cout << j_null.is_string() << '\\n';\n std::cout << j_boolean.is_string() << '\\n';\n std::cout << j_number_integer.is_string() << '\\n';\n std::cout << j_number_unsigned_integer.is_string() << '\\n';\n std::cout << j_number_float.is_string() << '\\n';\n std::cout << j_object.is_string() << '\\n';\n std::cout << j_array.is_string() << '\\n';\n std::cout << j_string.is_string() << '\\n';\n std::cout << j_binary.is_string() << '\\n';\n}\nOutput:
false\nfalse\nfalse\nfalse\nfalse\nfalse\nfalse\ntrue\nfalse\nconstexpr bool is_structured() const noexcept;\nThis function returns true if and only if the JSON type is structured (array or object).
true if type is structured (array or object), false otherwise.
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/is_structured/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/is_structured/#possible-implementation","title":"Possible implementation","text":"constexpr bool is_structured() const noexcept\n{\n return is_array() || is_object();\n}\nThe term structured stems from RFC 8259:
JSON can represent four primitive types (strings, numbers, booleans, and null) and two structured types (objects and arrays).
Note that though strings are containers in C++, they are treated as primitive values in JSON.
"},{"location":"api/basic_json/is_structured/#examples","title":"Examples","text":"ExampleThe following code exemplifies is_structured() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_number_unsigned_integer = 12345678987654321u;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n json j_binary = json::binary({1, 2, 3});\n\n // call is_structured()\n std::cout << std::boolalpha;\n std::cout << j_null.is_structured() << '\\n';\n std::cout << j_boolean.is_structured() << '\\n';\n std::cout << j_number_integer.is_structured() << '\\n';\n std::cout << j_number_unsigned_integer.is_structured() << '\\n';\n std::cout << j_number_float.is_structured() << '\\n';\n std::cout << j_object.is_structured() << '\\n';\n std::cout << j_array.is_structured() << '\\n';\n std::cout << j_string.is_structured() << '\\n';\n std::cout << j_binary.is_structured() << '\\n';\n}\nOutput:
false\nfalse\nfalse\nfalse\nfalse\ntrue\ntrue\nfalse\nfalse\niteration_proxy<iterator> items() noexcept;\niteration_proxy<const_iterator> items() const noexcept;\nThis function allows accessing iterator::key() and iterator::value() during range-based for loops. In these loops, a reference to the JSON values is returned, so there is no access to the underlying iterator.
For loop without items() function:
for (auto it = j_object.begin(); it != j_object.end(); ++it)\n{\n std::cout << \"key: \" << it.key() << \", value:\" << it.value() << '\\n';\n}\nRange-based for loop without items() function:
for (auto it : j_object)\n{\n // \"it\" is of type json::reference and has no key() member\n std::cout << \"value: \" << it << '\\n';\n}\nRange-based for loop with items() function:
for (auto& el : j_object.items())\n{\n std::cout << \"key: \" << el.key() << \", value:\" << el.value() << '\\n';\n}\nThe items() function also allows using structured bindings (C++17):
for (auto& [key, val] : j_object.items())\n{\n std::cout << \"key: \" << key << \", value:\" << val << '\\n';\n}\niteration proxy object wrapping the current value with an interface to use in range-based for loops
"},{"location":"api/basic_json/items/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/items/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/items/#notes","title":"Notes","text":"When iterating over an array, key() will return the index of the element as string (see example). For primitive types (e.g., numbers), key() returns an empty string.
Lifetime issues
Using items() on temporary objects is dangerous. Make sure the object's lifetime exceeds the iteration. See #2040 for more information.
The following code shows an example for items().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n\n // example for an object\n for (auto& x : j_object.items())\n {\n std::cout << \"key: \" << x.key() << \", value: \" << x.value() << '\\n';\n }\n\n // example for an array\n for (auto& x : j_array.items())\n {\n std::cout << \"key: \" << x.key() << \", value: \" << x.value() << '\\n';\n }\n}\nOutput:
key: one, value: 1\nkey: two, value: 2\nkey: 0, value: 1\nkey: 1, value: 2\nkey: 2, value: 4\nkey: 3, value: 8\nkey: 4, value: 16\niterator_wrapper in version 3.0.0.items and deprecated iterator_wrapper in version 3.1.0.Deprecation
This function replaces the static function iterator_wrapper which was introduced in version 1.0.0, but has been deprecated in version 3.1.0. Function iterator_wrapper will be removed in version 4.0.0. Please replace all occurrences of iterator_wrapper(j) with j.items().
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
using json_base_class_t = detail::json_base_class<CustomBaseClass>;\nThe base class used to inject custom functionality into each instance of basic_json. Examples of such functionality might be metadata, additional member functions (e.g., visitors), or other application-specific code.
CustomBaseClass the base class to be added to basic_json"},{"location":"api/basic_json/json_base_class_t/#notes","title":"Notes","text":""},{"location":"api/basic_json/json_base_class_t/#default-type","title":"Default type","text":"The default value for CustomBaseClass is void. In this case, an empty base class is used and no additional functionality is injected.
The type CustomBaseClass has to be a default-constructible class. basic_json only supports copy/move construction/assignment if CustomBaseClass does so as well.
The following code shows how to inject custom data and methods for each node.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nclass visitor_adaptor_with_metadata\n{\n public:\n template <class Fnc>\n void visit(const Fnc& fnc) const;\n\n int metadata = 42;\n private:\n template <class Ptr, class Fnc>\n void do_visit(const Ptr& ptr, const Fnc& fnc) const;\n};\n\nusing json = nlohmann::basic_json <\n std::map,\n std::vector,\n std::string,\n bool,\n std::int64_t,\n std::uint64_t,\n double,\n std::allocator,\n nlohmann::adl_serializer,\n std::vector<std::uint8_t>,\n visitor_adaptor_with_metadata\n >;\n\ntemplate <class Fnc>\nvoid visitor_adaptor_with_metadata::visit(const Fnc& fnc) const\n{\n do_visit(json::json_pointer{}, fnc);\n}\n\ntemplate <class Ptr, class Fnc>\nvoid visitor_adaptor_with_metadata::do_visit(const Ptr& ptr, const Fnc& fnc) const\n{\n using value_t = nlohmann::detail::value_t;\n const json& j = *static_cast<const json*>(this);\n switch (j.type())\n {\n case value_t::object:\n fnc(ptr, j);\n for (const auto& entry : j.items())\n {\n entry.value().do_visit(ptr / entry.key(), fnc);\n }\n break;\n case value_t::array:\n fnc(ptr, j);\n for (std::size_t i = 0; i < j.size(); ++i)\n {\n j.at(i).do_visit(ptr / std::to_string(i), fnc);\n }\n break;\n case value_t::null:\n case value_t::string:\n case value_t::boolean:\n case value_t::number_integer:\n case value_t::number_unsigned:\n case value_t::number_float:\n case value_t::binary:\n fnc(ptr, j);\n break;\n case value_t::discarded:\n default:\n break;\n }\n}\n\nint main()\n{\n // create a json object\n json j;\n j[\"null\"];\n j[\"object\"][\"uint\"] = 1U;\n j[\"object\"].metadata = 21;\n\n // visit and output\n j.visit(\n [&](const json::json_pointer & p,\n const json & j)\n {\n std::cout << (p.empty() ? std::string{\"/\"} : p.to_string())\n << \" - metadata = \" << j.metadata << \" -> \" << j.dump() << '\\n';\n });\n}\nOutput:
/ - metadata = 42 -> {\"null\":null,\"object\":{\"uint\":1}}\n/null - metadata = 42 -> null\n/object - metadata = 21 -> {\"uint\":1}\n/object/uint - metadata = 42 -> 1\ntemplate<typename T, typename SFINAE>\nusing json_serializer = JSONSerializer<T, SFINAE>;\nT type to convert; will be used in the to_json/from_json functions SFINAE type to add compile type checks via SFINAE; usually void"},{"location":"api/basic_json/json_serializer/#notes","title":"Notes","text":""},{"location":"api/basic_json/json_serializer/#default-type","title":"Default type","text":"The default values for json_serializer is adl_serializer.
The example below shows how a conversion of a non-default-constructible type is implemented via a specialization of the adl_serializer.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\n// a simple struct to model a person (not default constructible)\nstruct person\n{\n person(std::string n, std::string a, int aa)\n : name(std::move(n)), address(std::move(a)), age(aa)\n {}\n\n std::string name;\n std::string address;\n int age;\n};\n} // namespace ns\n\nnamespace nlohmann\n{\ntemplate <>\nstruct adl_serializer<ns::person>\n{\n static ns::person from_json(const json& j)\n {\n return {j.at(\"name\"), j.at(\"address\"), j.at(\"age\")};\n }\n\n // Here's the catch! You must provide a to_json method! Otherwise, you\n // will not be able to convert person to json, since you fully\n // specialized adl_serializer on that type\n static void to_json(json& j, ns::person p)\n {\n j[\"name\"] = p.name;\n j[\"address\"] = p.address;\n j[\"age\"] = p.age;\n }\n};\n} // namespace nlohmann\n\nint main()\n{\n json j;\n j[\"name\"] = \"Ned Flanders\";\n j[\"address\"] = \"744 Evergreen Terrace\";\n j[\"age\"] = 60;\n\n auto p = j.get<ns::person>();\n\n std::cout << p.name << \" (\" << p.age << \") lives in \" << p.address << std::endl;\n}\nOutput:
Ned Flanders (60) lives in 744 Evergreen Terrace\nsize_type max_size() const noexcept;\nReturns the maximum number of elements a JSON value is able to hold due to system or library implementation limitations, i.e. std::distance(begin(), end()) for the JSON value.
The return value depends on the different types and is defined as follows:
Value type return value null0 (same as size()) boolean 1 (same as size()) string 1 (same as size()) number 1 (same as size()) binary 1 (same as size()) object result of function object_t::max_size() array result of function array_t::max_size()"},{"location":"api/basic_json/max_size/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/max_size/#complexity","title":"Complexity","text":"Constant, as long as array_t and object_t satisfy the Container concept; that is, their max_size() functions have constant complexity.
This function does not return the maximal length of a string stored as JSON value -- it returns the maximal number of string elements the JSON value can store which is 1.
The following code calls max_size() on the different value types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n\n // call max_size()\n std::cout << j_null.max_size() << '\\n';\n std::cout << j_boolean.max_size() << '\\n';\n std::cout << j_number_integer.max_size() << '\\n';\n std::cout << j_number_float.max_size() << '\\n';\n std::cout << j_object.max_size() << '\\n';\n std::cout << j_array.max_size() << '\\n';\n std::cout << j_string.max_size() << '\\n';\n}\nOutput:
0\n1\n1\n1\n115292150460684697\n576460752303423487\n1\nNote the output is platform-dependent.
"},{"location":"api/basic_json/max_size/#version-history","title":"Version history","text":"1 for binary types in version 3.8.0.void merge_patch(const basic_json& apply_patch);\nThe merge patch format is primarily intended for use with the HTTP PATCH method as a means of describing a set of modifications to a target resource's content. This function applies a merge patch to the current JSON value.
The function implements the following algorithm from Section 2 of RFC 7396 (JSON Merge Patch):
define MergePatch(Target, Patch):\n if Patch is an Object:\n if Target is not an Object:\n Target = {} // Ignore the contents and set it to an empty Object\n for each Name/Value pair in Patch:\n if Value is null:\n if Name exists in Target:\n remove the Name/Value pair from Target\n else:\n Target[Name] = MergePatch(Target[Name], Value)\n return Target\n else:\n return Patch\nThereby, Target is the current object; that is, the patch is applied to the current value.
apply_patch (in) the patch to apply"},{"location":"api/basic_json/merge_patch/#complexity","title":"Complexity","text":"Linear in the lengths of apply_patch.
The following code shows how a JSON Merge Patch is applied to a JSON document.
#include <iostream>\n#include <nlohmann/json.hpp>\n#include <iomanip> // for std::setw\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // the original document\n json document = R\"({\n \"title\": \"Goodbye!\",\n \"author\": {\n \"givenName\": \"John\",\n \"familyName\": \"Doe\"\n },\n \"tags\": [\n \"example\",\n \"sample\"\n ],\n \"content\": \"This will be unchanged\"\n })\"_json;\n\n // the patch\n json patch = R\"({\n \"title\": \"Hello!\",\n \"phoneNumber\": \"+01-123-456-7890\",\n \"author\": {\n \"familyName\": null\n },\n \"tags\": [\n \"example\"\n ]\n })\"_json;\n\n // apply the patch\n document.merge_patch(patch);\n\n // output original and patched document\n std::cout << std::setw(4) << document << std::endl;\n}\nOutput:
{\n \"author\": {\n \"givenName\": \"John\"\n },\n \"content\": \"This will be unchanged\",\n \"phoneNumber\": \"+01-123-456-7890\",\n \"tags\": [\n \"example\"\n ],\n \"title\": \"Hello!\"\n}\nstatic basic_json meta();\nThis function returns a JSON object with information about the library, including the version number and information on the platform and compiler.
"},{"location":"api/basic_json/meta/#return-value","title":"Return value","text":"JSON object holding version information
key descriptioncompiler Information on the used compiler. It is an object with the following keys: c++ (the used C++ standard), family (the compiler family; possible values are clang, icc, gcc, ilecpp, msvc, pgcpp, sunpro, and unknown), and version (the compiler version). On HP aCC compilers, compiler is instead the plain string hp. copyright The copyright line for the library as string. name The name of the library as string. platform The used platform as string. Possible values are win32, linux, apple, unix, and unknown. url The URL of the project as string. version The version of the library. It is an object with the following keys: major, minor, and patch as defined by Semantic Versioning, and string (the version string)."},{"location":"api/basic_json/meta/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
"},{"location":"api/basic_json/meta/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/meta/#examples","title":"Examples","text":"ExampleThe following code shows an example output of the meta() function.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // call meta()\n std::cout << std::setw(4) << json::meta() << '\\n';\n}\nOutput:
{\n \"compiler\": {\n \"c++\": \"201103\",\n \"family\": \"gcc\",\n \"version\": \"12.4.0\"\n },\n \"copyright\": \"(C) 2013-2026 Niels Lohmann\",\n \"name\": \"JSON for Modern C++\",\n \"platform\": \"apple\",\n \"url\": \"https://github.com/nlohmann/json\",\n \"version\": {\n \"major\": 3,\n \"minor\": 12,\n \"patch\": 0,\n \"string\": \"3.12.0\"\n }\n}\nNote the output is platform-dependent.
"},{"location":"api/basic_json/meta/#see-also","title":"See also","text":"using number_float_t = NumberFloatType;\nThe type used to store JSON numbers (floating-point).
RFC 8259 describes numbers as follows:
The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.
This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer, or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.
To store floating-point numbers in C++, a type is defined by the template parameter NumberFloatType which chooses the type to use.
With the default values for NumberFloatType (double), the default value for number_float_t is double.
01.2 will be serialized to 1.2. During deserialization, leading zeros yield an error.null.RFC 8259 states:
This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754-2008 binary64 (double precision) numbers is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.
This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values smaller than -1.79769313486232e+308 and values greater than 1.79769313486232e+308 will be stored as NaN internally and be serialized to null.
Floating-point number values are stored directly inside a basic_json type.
The following code shows that number_float_t is by default, a typedef to double.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha << std::is_same<double, json::number_float_t>::value << std::endl;\n}\nOutput:
true\nusing number_integer_t = NumberIntegerType;\nThe type used to store JSON numbers (integers).
RFC 8259 describes numbers as follows:
The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.
This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer, or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.
To store integer numbers in C++, a type is defined by the template parameter NumberIntegerType which chooses the type to use.
With the default values for NumberIntegerType (std::int64_t), the default value for number_integer_t is std::int64_t.
010 will be serialized to 8. During deserialization, leading zeros yield an error.RFC 8259 specifies:
An implementation may set limits on the range and precision of numbers.
When the default type is used, the maximal integer number that can be stored is 9223372036854775807 (INT64_MAX) and the minimal integer number that can be stored is -9223372036854775808 (INT64_MIN). Integer numbers that are out of range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored as number_unsigned_t or number_float_t.
RFC 8259 further states:
Note that when such software is used, numbers that are integers and are in the range [-2^{53}+1, 2^{53}-1] are interoperable in the sense that implementations will agree exactly on their numeric values.
As this range is a subrange of the exactly supported range [INT64_MIN, INT64_MAX], this class's integer type is interoperable.
"},{"location":"api/basic_json/number_integer_t/#storage","title":"Storage","text":"Integer number values are stored directly inside a basic_json type.
The following code shows that number_integer_t is by default, a typedef to std::int64_t.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha << std::is_same<std::int64_t, json::number_integer_t>::value << std::endl;\n}\nOutput:
true\nusing number_unsigned_t = NumberUnsignedType;\nThe type used to store JSON numbers (unsigned).
RFC 8259 describes numbers as follows:
The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.
This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer, or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.
To store unsigned integer numbers in C++, a type is defined by the template parameter NumberUnsignedType which chooses the type to use.
With the default values for NumberUnsignedType (std::uint64_t), the default value for number_unsigned_t is std::uint64_t.
010 will be serialized to 8. During deserialization, leading zeros yield an error.RFC 8259 specifies:
An implementation may set limits on the range and precision of numbers.
When the default type is used, the maximal integer number that can be stored is 18446744073709551615 (UINT64_MAX) and the minimal integer number that can be stored is 0. Integer numbers that are out of range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored as number_integer_t or number_float_t.
RFC 8259 further states:
Note that when such software is used, numbers that are integers and are in the range [-2^{53}+1, 2^{53}-1] are interoperable in the sense that implementations will agree exactly on their numeric values.
As this range is a subrange (when considered in conjunction with the number_integer_t type) of the exactly supported range [0, UINT64_MAX], this class's integer type is interoperable.
Integer number values are stored directly inside a basic_json type.
The following code shows that number_unsigned_t is by default, a typedef to std::uint64_t.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha << std::is_same<std::uint64_t, json::number_unsigned_t>::value << std::endl;\n}\nOutput:
true\nstatic basic_json object(initializer_list_t init = {});\nCreates a JSON object value from a given initializer list. The initializer lists elements must be pairs, and their first elements must be strings. If the initializer list is empty, the empty object {} is created.
init (in) initializer list with JSON values to create an object from (optional)"},{"location":"api/basic_json/object/#return-value","title":"Return value","text":"JSON object value
"},{"location":"api/basic_json/object/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/object/#exceptions","title":"Exceptions","text":"Throws type_error.301 if init is not a list of pairs whose first elements are strings. In this case, no object can be created. When such a value is passed to basic_json(initializer_list_t, bool, value_t), an array would have been created from the passed initializer list init. See the example below.
Linear in the size of init.
This function is only added for symmetry reasons. In contrast to the related function array(initializer_list_t), there are no cases that can only be expressed by this function. That is, any initializer list init can also be passed to the initializer list constructor basic_json(initializer_list_t, bool, value_t).
The following code shows an example for the object function.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON objects\n json j_no_init_list = json::object();\n json j_empty_init_list = json::object({});\n json j_list_of_pairs = json::object({ {\"one\", 1}, {\"two\", 2} });\n\n // serialize the JSON objects\n std::cout << j_no_init_list << '\\n';\n std::cout << j_empty_init_list << '\\n';\n std::cout << j_list_of_pairs << '\\n';\n\n // example for an exception\n try\n {\n // can only create an object from a list of pairs\n json j_invalid_object = json::object({{ \"one\", 1, 2 }});\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
{}\n{}\n{\"one\":1,\"two\":2}\n[json.exception.type_error.301] cannot create object from initializer list\nbasic_json(initializer_list_t) - create a JSON value from an initializer listarray - create a JSON array value from an initializer listusing object_comparator_t = typename object_t::key_compare;\n// or\nusing object_comparator_t = default_object_comparator_t;\nThe comparator used by object_t. Defined as typename object_t::key_compare if available, and default_object_comparator_t otherwise.
The example below demonstrates the used object comparator.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha\n << \"json::object_comparator_t(\\\"one\\\", \\\"two\\\") = \" << json::object_comparator_t{}(\"one\", \"two\") << \"\\n\"\n << \"json::object_comparator_t(\\\"three\\\", \\\"four\\\") = \" << json::object_comparator_t{}(\"three\", \"four\") << std::endl;\n}\nOutput:
json::object_comparator_t(\"one\", \"two\") = true\njson::object_comparator_t(\"three\", \"four\") = false\ntypename object_t::key_compare or default_object_comparator_t in version 3.11.0.using object_t = ObjectType<StringType,\n basic_json,\n default_object_comparator_t,\n AllocatorType<std::pair<const StringType, basic_json>>>;\nThe type used to store JSON objects.
RFC 8259 describes JSON objects as follows:
An object is an unordered collection of zero or more name/value pairs, where a name is a string and a value is a string, number, boolean, null, object, or array.
To store objects in C++, a type is defined by the template parameters described below.
"},{"location":"api/basic_json/object_t/#template-parameters","title":"Template parameters","text":"ObjectType the container to store objects (e.g., std::map or std::unordered_map) StringType the type of the keys or names (e.g., std::string). The comparison function std::less<StringType> is used to order elements inside the container. AllocatorType the allocator to use for objects (e.g., std::allocator)"},{"location":"api/basic_json/object_t/#notes","title":"Notes","text":""},{"location":"api/basic_json/object_t/#default-type","title":"Default type","text":"With the default values for ObjectType (std::map), StringType (std::string), and AllocatorType (std::allocator), the default value for object_t is:
// until C++14\nstd::map<\n std::string, // key_type\n basic_json, // value_type\n std::less<std::string>, // key_compare\n std::allocator<std::pair<const std::string, basic_json>> // allocator_type\n>\n\n// since C++14\nstd::map<\n std::string, // key_type\n basic_json, // value_type\n std::less<>, // key_compare\n std::allocator<std::pair<const std::string, basic_json>> // allocator_type\n>\nSee default_object_comparator_t for more information.
The choice of object_t influences the behavior of the JSON class. With the default type, objects have the following behavior:
{\"key\": 2, \"key\": 1} could be equal to either {\"key\": 1} or {\"key\": 2}.dump) in this order. For instance, {\"b\": 1, \"a\": 2} and {\"a\": 2, \"b\": 1} will be stored and serialized as {\"a\": 2, \"b\": 1}.{\"b\": 1, \"a\": 2} and {\"a\": 2, \"b\": 1} will be treated as equal.RFC 8259 specifies:
An implementation may set limits on the maximum depth of nesting.
In this class, the object's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON object.
Objects are stored as pointers in a basic_json type. That is, for any access to object values, a pointer of type object_t* must be dereferenced.
The order name/value pairs are added to the object are not preserved by the library. Therefore, iterating an object may return name/value pairs in a different order than they were originally stored. In fact, keys will be traversed in alphabetical order as std::map with std::less is used by default. Please note this behavior conforms to RFC 8259, because any order implements the specified \"unordered\" nature of JSON objects.
basic_json conversion requirements","text":"When converting an object from one basic_json specialization to another via the converting constructor, the target object_t's key_type must be directly constructible from the source basic_json's string_t type (or more generally, from the source object's key type). If this requirement is not met, the conversion does not fail; instead, the object is silently converted as an array of key-value pairs, which is incorrect. See issue #3425 for details and an example.
The following code shows that object_t is by default, a typedef to std::map<json::string_t, json>.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha << std::is_same<std::map<json::string_t, json>, json::object_t>::value << std::endl;\n}\nOutput:
true\n// (1)\nreference operator+=(basic_json&& val);\nreference operator+=(const basic_json& val);\n\n// (2)\nreference operator+=(const typename object_t::value_type& val);\n\n// (3)\nreference operator+=(initializer_list_t init);\nAppends the given element val to the end of the JSON array. If the function is called on a JSON null value, an empty array is created before appending val.
Inserts the given element val to the JSON object. If the function is called on a JSON null value, an empty object is created before inserting val.
This function allows using operator+= with an initializer list. In case
init contains only two elements, andinit is a string,init is converted into an object element and added using operator+=(const typename object_t::value_type&). Otherwise, init is converted to a JSON value and added using operator+=(basic_json&&).
For all cases where an element is added to an array, a reallocation can happen, in which case all iterators (including the end() iterator) and all references to the elements are invalidated. Otherwise, only the end() iterator is invalidated.
For ordered_json, also adding an element to an object can yield a reallocation which again invalidates all iterators and all references.
val (in) the value to add to the JSON array/object init (in) an initializer list"},{"location":"api/basic_json/operator%2B%3D/#return-value","title":"Return value","text":"*this
type_error.308 when called on a type other than JSON array or null; example: \"cannot use push_back() with number\"type_error.308 when called on a type other than JSON object or null; example: \"cannot use push_back() with number\"type_error.308 when called on a type other than JSON array or null; example: \"cannot use push_back() with number\"size())).init.(3) This function is required to resolve an ambiguous overload error, because pairs like {\"key\", \"value\"} can be both interpreted as object_t::value_type or std::initializer_list<basic_json>, see #235 for more information.
The example shows how push_back() and += can be used to add elements to a JSON array. Note how the null value was silently converted to a JSON array.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json array = {1, 2, 3, 4, 5};\n json null;\n\n // print values\n std::cout << array << '\\n';\n std::cout << null << '\\n';\n\n // add values\n array.push_back(6);\n array += 7;\n null += \"first\";\n null += \"second\";\n\n // print values\n std::cout << array << '\\n';\n std::cout << null << '\\n';\n}\nOutput:
[1,2,3,4,5]\nnull\n[1,2,3,4,5,6,7]\n[\"first\",\"second\"]\nThe example shows how push_back() and += can be used to add elements to a JSON object. Note how the null value was silently converted to a JSON object.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json object = {{\"one\", 1}, {\"two\", 2}};\n json null;\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n\n // add values\n object.push_back(json::object_t::value_type(\"three\", 3));\n object += json::object_t::value_type(\"four\", 4);\n null += json::object_t::value_type(\"A\", \"a\");\n null += json::object_t::value_type(\"B\", \"b\");\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n}\nOutput:
{\"one\":1,\"two\":2}\nnull\n{\"four\":4,\"one\":1,\"three\":3,\"two\":2}\n{\"A\":\"a\",\"B\":\"b\"}\nThe example shows how initializer lists are treated as objects when possible.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json object = {{\"one\", 1}, {\"two\", 2}};\n json null;\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n\n // add values:\n object.push_back({\"three\", 3}); // object is extended\n object += {\"four\", 4}; // object is extended\n null.push_back({\"five\", 5}); // null is converted to array\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n\n // would throw:\n //object.push_back({1, 2, 3});\n}\nOutput:
{\"one\":1,\"two\":2}\nnull\n{\"four\":4,\"one\":1,\"three\":3,\"two\":2}\n[[\"five\",5]]\nbasic_json& operator=(basic_json other) noexcept (\n std::is_nothrow_move_constructible<value_t>::value &&\n std::is_nothrow_move_assignable<value_t>::value &&\n std::is_nothrow_move_constructible<json_value>::value &&\n std::is_nothrow_move_assignable<json_value>::value &&\n std::is_nothrow_move_assignable<json_base_class_t>::value\n);\nCopy assignment operator. Copies a JSON value via the \"copy and swap\" strategy: It is expressed in terms of the copy constructor, destructor, and the swap() member function.
other (in) value to copy from"},{"location":"api/basic_json/operator%3D/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown while copying other, there are no changes to *this.
Linear.
"},{"location":"api/basic_json/operator%3D/#examples","title":"Examples","text":"ExampleThe code below shows and example for the copy assignment. It creates a copy of value a which is then swapped with b. Finally, the copy of a (which is the null value after the swap) is destroyed.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json a = 23;\n json b = 42;\n\n // copy-assign a to b\n b = a;\n\n // serialize the JSON arrays\n std::cout << a << '\\n';\n std::cout << b << '\\n';\n}\nOutput:
23\n23\n// (1)\nreference operator[](size_type idx);\nconst_reference operator[](size_type idx) const;\n\n// (2)\nreference operator[](typename object_t::key_type key);\nconst_reference operator[](const typename object_t::key_type& key) const;\n\n// (3)\ntemplate<typename KeyType>\nreference operator[](KeyType&& key);\ntemplate<typename KeyType>\nconst_reference operator[](KeyType&& key) const;\n\n// (4)\nreference operator[](const json_pointer& ptr);\nconst_reference operator[](const json_pointer& ptr) const;\nidx.key. The non-const qualified overload takes the key by value.KeyType is comparable with typename object_t::key_type and typename object_comparator_t::is_transparent denotes a type.ptr.KeyType A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17)."},{"location":"api/basic_json/operator%5B%5D/#iterator-invalidation","title":"Iterator invalidation","text":"For the non-const versions 1. and 4., when passing an array index that does not exist, it is created and filled with a null value before a reference to it is returned. For this, a reallocation can happen, in which case all iterators (including the end() iterator) and all references to the elements are invalidated.
For ordered_json, also passing an object key to the non-const versions 2., 3., and 4., a reallocation can happen which again invalidates all iterators and all references.
idx (in) index of the element to access key (in) object key of the element to access ptr (in) JSON pointer to the desired element"},{"location":"api/basic_json/operator%5B%5D/#return-value","title":"Return value","text":"idxkeykeyptrStrong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/operator%5B%5D/#exceptions","title":"Exceptions","text":"type_error.305 if the JSON value is not an array or null; in that case, using the [] operator with an index makes no sense.type_error.305 if the JSON value is not an object or null; in that case, using the [] operator with a key makes no sense.parse_error.106 if an array index in the passed JSON pointer ptr begins with '0'.parse_error.109 if an array index in the passed JSON pointer ptr is not a number.out_of_range.402 if the array index '-' is used in the passed JSON pointer ptr for the const version.out_of_range.404 if the JSON pointer ptr can not be resolved.out_of_range.410 if an array index in the passed JSON pointer ptr exceeds the range of size_type (e.g., on 32-bit platforms).idx is in the range of the array. Otherwise, linear in idx - size().Undefined behavior and runtime assertions
The following cases apply to the const overloads; the non-const overloads instead insert the missing element (see the notes below).
idx does not exist, the behavior is undefined.key does not exist, the behavior is undefined and is guarded by a runtime assertion!The non-const version may add values: If idx is beyond the range of the array (i.e., idx >= size()), then the array is silently filled up with null values to make idx a valid reference to the last stored element. In case the value was null before, it is converted to an array.
If key is not found in the object, then it is silently added to the object and filled with a null value to make key a valid reference. In case the value was null before, it is converted to an object.
See 2.
null values are created in arrays and objects if necessary.
In particular:
null value before a reference to it is returned.null value before a reference to it is returned. All indices between the current maximum and the given index are also filled with null.- is treated as a synonym for the index past the end.The example below shows how array elements can be read and written using [] operator. Note the addition of null values.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON array\n json array = {1, 2, 3, 4, 5};\n\n // output element at index 3 (fourth element)\n std::cout << array[3] << '\\n';\n\n // change last element to 6\n array[array.size() - 1] = 6;\n\n // output changed array\n std::cout << array << '\\n';\n\n // write beyond array limit\n array[10] = 11;\n\n // output changed array\n std::cout << array << '\\n';\n}\nOutput:
4\n[1,2,3,4,6]\n[1,2,3,4,6,null,null,null,null,null,11]\nThe example below shows how array elements can be read using the [] operator.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON array\n const json array = {\"first\", \"2nd\", \"third\", \"fourth\"};\n\n // output element at index 2 (third element)\n std::cout << array.at(2) << '\\n';\n}\nOutput:
\"third\"\nThe example below shows how object elements can be read and written using the [] operator.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json object =\n {\n {\"one\", 1}, {\"two\", 2}, {\"three\", 2.9}\n };\n\n // output element with key \"two\"\n std::cout << object[\"two\"] << \"\\n\\n\";\n\n // change element with key \"three\"\n object[\"three\"] = 3;\n\n // output changed array\n std::cout << std::setw(4) << object << \"\\n\\n\";\n\n // mention nonexisting key\n object[\"four\"];\n\n // write to nonexisting key\n object[\"five\"][\"really\"][\"nested\"] = true;\n\n // output changed object\n std::cout << std::setw(4) << object << '\\n';\n}\nOutput:
2\n\n{\n \"one\": 1,\n \"three\": 3,\n \"two\": 2\n}\n\n{\n \"five\": {\n \"really\": {\n \"nested\": true\n }\n },\n \"four\": null,\n \"one\": 1,\n \"three\": 3,\n \"two\": 2\n}\nThe example below shows how object elements can be read using the [] operator.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n const json object =\n {\n {\"one\", 1}, {\"two\", 2}, {\"three\", 2.9}\n };\n\n // output element with key \"two\"\n std::cout << object[\"two\"] << '\\n';\n}\nOutput:
2\nThe example below shows how object elements can be read using the [] operator.
#include <iostream>\n#include <iomanip>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n json object =\n {\n {\"one\", 1}, {\"two\", 2}, {\"three\", 2.9}\n };\n\n // output element with key \"two\"\n std::cout << object[\"two\"sv] << \"\\n\\n\";\n\n // change element with key \"three\"\n object[\"three\"sv] = 3;\n\n // output changed array\n std::cout << std::setw(4) << object << \"\\n\\n\";\n\n // mention nonexisting key\n object[\"four\"sv];\n\n // write to nonexisting key\n object[\"five\"sv][\"really\"sv][\"nested\"sv] = true;\n\n // output changed object\n std::cout << std::setw(4) << object << '\\n';\n}\nOutput:
2\n\n{\n \"one\": 1,\n \"three\": 3,\n \"two\": 2\n}\n\n{\n \"five\": {\n \"really\": {\n \"nested\": true\n }\n },\n \"four\": null,\n \"one\": 1,\n \"three\": 3,\n \"two\": 2\n}\nThe example below shows how object elements can be read using the [] operator.
#include <iostream>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object\n const json object =\n {\n {\"one\", 1}, {\"two\", 2}, {\"three\", 2.9}\n };\n\n // output element with key \"two\"\n std::cout << object[\"two\"sv] << '\\n';\n}\nOutput:
2\nThe example below shows how values can be read and written using JSON Pointers.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j =\n {\n {\"number\", 1}, {\"string\", \"foo\"}, {\"array\", {1, 2}}\n };\n\n // read-only access\n\n // output element with JSON pointer \"/number\"\n std::cout << j[\"/number\"_json_pointer] << '\\n';\n // output element with JSON pointer \"/string\"\n std::cout << j[\"/string\"_json_pointer] << '\\n';\n // output element with JSON pointer \"/array\"\n std::cout << j[\"/array\"_json_pointer] << '\\n';\n // output element with JSON pointer \"/array/1\"\n std::cout << j[\"/array/1\"_json_pointer] << '\\n';\n\n // writing access\n\n // change the string\n j[\"/string\"_json_pointer] = \"bar\";\n // output the changed string\n std::cout << j[\"string\"] << '\\n';\n\n // \"change\" a nonexisting object entry\n j[\"/boolean\"_json_pointer] = true;\n // output the changed object\n std::cout << j << '\\n';\n\n // change an array element\n j[\"/array/1\"_json_pointer] = 21;\n // \"change\" an array element with nonexisting index\n j[\"/array/4\"_json_pointer] = 44;\n // output the changed array\n std::cout << j[\"array\"] << '\\n';\n\n // \"change\" the array element past the end\n j[\"/array/-\"_json_pointer] = 55;\n // output the changed array\n std::cout << j[\"array\"] << '\\n';\n}\nOutput:
1\n\"foo\"\n[1,2]\n2\n\"bar\"\n{\"array\":[1,2],\"boolean\":true,\"number\":1,\"string\":\"bar\"}\n[1,21,null,null,44]\n[1,21,null,null,44,55]\nThe example below shows how values can be read using JSON Pointers.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n const json j =\n {\n {\"number\", 1}, {\"string\", \"foo\"}, {\"array\", {1, 2}}\n };\n\n // read-only access\n\n // output element with JSON pointer \"/number\"\n std::cout << j[\"/number\"_json_pointer] << '\\n';\n // output element with JSON pointer \"/string\"\n std::cout << j[\"/string\"_json_pointer] << '\\n';\n // output element with JSON pointer \"/array\"\n std::cout << j[\"/array\"_json_pointer] << '\\n';\n // output element with JSON pointer \"/array/1\"\n std::cout << j[\"/array/1\"_json_pointer] << '\\n';\n}\nOutput:
1\n\"foo\"\n[1,2]\n2\nat for access by reference with range checkingvalue for access with default valueT* key in version 1.1.0. Removed overloads for T* key (replaced by 3) in version 3.11.0.template<typename ValueType>\nJSON_EXPLICIT operator ValueType() const;\nImplicit type conversion between the JSON value and a compatible value. The call is realized by calling get(). See Notes for the meaning of JSON_EXPLICIT.
ValueType the value type to return"},{"location":"api/basic_json/operator_ValueType/#return-value","title":"Return value","text":"copy of the JSON value, converted to ValueType
Depends on what json_serializer<ValueType> from_json() method throws
Linear in the size of the JSON value.
"},{"location":"api/basic_json/operator_ValueType/#notes","title":"Notes","text":"Definition of JSON_EXPLICIT
By default JSON_EXPLICIT is defined to the empty string, so the signature is:
template<typename ValueType>\noperator ValueType() const;\nIf JSON_USE_IMPLICIT_CONVERSIONS is set to 0, JSON_EXPLICIT is defined to explicit:
template<typename ValueType>\nexplicit operator ValueType() const;\nThat is, implicit conversions can be switched off by defining JSON_USE_IMPLICIT_CONVERSIONS to 0.
Future behavior change
Implicit conversions will be switched off by default in the next major release of the library. That is, JSON_EXPLICIT will be set to explicit by default.
You can prepare existing code by already defining JSON_USE_IMPLICIT_CONVERSIONS to 0 and replace any implicit conversions with calls to get.
The example below shows several conversions from JSON values to other types. There are a few things to note: (1) Floating-point numbers can be converted to integers, (2) A JSON array can be converted to a standard std::vector<short>, (3) A JSON object can be converted to C++ associative containers such as std::unordered_map<std::string, json>.
#include <iostream>\n#include <unordered_map>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value with different types\n json json_types =\n {\n {\"boolean\", true},\n {\n \"number\", {\n {\"integer\", 42},\n {\"floating-point\", 17.23}\n }\n },\n {\"string\", \"Hello, world!\"},\n {\"array\", {1, 2, 3, 4, 5}},\n {\"null\", nullptr}\n };\n\n // use implicit conversions\n bool v1 = json_types[\"boolean\"];\n int v2 = json_types[\"number\"][\"integer\"];\n short v3 = json_types[\"number\"][\"integer\"];\n float v4 = json_types[\"number\"][\"floating-point\"];\n int v5 = json_types[\"number\"][\"floating-point\"];\n std::string v6 = json_types[\"string\"];\n std::vector<short> v7 = json_types[\"array\"];\n std::unordered_map<std::string, json> v8 = json_types;\n\n // print the conversion results\n std::cout << v1 << '\\n';\n std::cout << v2 << ' ' << v3 << '\\n';\n std::cout << v4 << ' ' << v5 << '\\n';\n std::cout << v6 << '\\n';\n\n for (auto i : v7)\n {\n std::cout << i << ' ';\n }\n std::cout << \"\\n\\n\";\n\n for (auto i : v8)\n {\n std::cout << i.first << \": \" << i.second << '\\n';\n }\n\n // example for an exception\n try\n {\n bool v1 = json_types[\"string\"];\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
1\n42 42\n17.23 17\nHello, world!\n1 2 3 4 5 \n\nstring: \"Hello, world!\"\nnumber: {\"floating-point\":17.23,\"integer\":42}\nnull: null\nboolean: true\narray: [1,2,3,4,5]\n[json.exception.type_error.302] type must be boolean, but is string\nJSON_EXPLICIT/JSON_USE_IMPLICIT_CONVERSIONS added in version 3.9.0.// until C++20\nbool operator==(const_reference lhs, const_reference rhs) noexcept; // (1)\n\ntemplate<typename ScalarType>\nbool operator==(const_reference lhs, const ScalarType rhs) noexcept; // (2)\n\ntemplate<typename ScalarType>\nbool operator==(ScalarType lhs, const const_reference rhs) noexcept; // (2)\n\n// since C++20\nclass basic_json {\n bool operator==(const_reference rhs) const noexcept; // (1)\n\n template<typename ScalarType>\n bool operator==(ScalarType rhs) const noexcept; // (2)\n};\nCompares two JSON values for equality according to the following rules:
operator==.Compares a JSON value and a scalar or a scalar and a JSON value for equality by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType a scalar type according to std::is_scalar<ScalarType>::value"},{"location":"api/basic_json/operator_eq/#parameters","title":"Parameters","text":"lhs (in) first value to consider rhs (in) second value to consider"},{"location":"api/basic_json/operator_eq/#return-value","title":"Return value","text":"whether the values lhs/*this and rhs are equal
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/operator_eq/#complexity","title":"Complexity","text":"Linear.
"},{"location":"api/basic_json/operator_eq/#notes","title":"Notes","text":"Comparing special values
NaN values are unordered within the domain of numbers. The following comparisons all yield false:NaN with itself.NaN with another NaN.NaN and any other number.null values are all equal.Comparing floating-point numbers
Floating-point numbers inside JSON values numbers are compared with json::number_float_t::operator== which is double::operator== by default. To compare floating-point while respecting an epsilon, an alternative comparison function could be used, for instance
template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>\ninline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept\n{\n return std::abs(a - b) <= epsilon;\n}\nOr you can define your own equality function like this:
bool my_equal(const_reference lhs, const_reference rhs)\n{\n const auto lhs_type = lhs.type();\n const auto rhs_type = rhs.type();\n if (lhs_type == rhs_type)\n {\n switch(lhs_type)\n // self_defined case\n case value_t::number_float:\n return std::abs(lhs - rhs) <= std::numeric_limits<float>::epsilon();\n // other cases remain the same with the original\n ...\n }\n...\n}\nComparing different basic_json specializations
Comparing different basic_json specializations can have surprising effects. For instance, the result of comparing the JSON objects
{\n \"version\": 1,\n \"type\": \"integer\"\n}\nand
{\n \"type\": \"integer\",\n \"version\": 1\n}\ndepends on whether nlohmann::json or nlohmann::ordered_json is used:
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n nlohmann::json uj1 = {{\"version\", 1}, {\"type\", \"integer\"}};\n nlohmann::json uj2 = {{\"type\", \"integer\"}, {\"version\", 1}};\n\n nlohmann::ordered_json oj1 = {{\"version\", 1}, {\"type\", \"integer\"}};\n nlohmann::ordered_json oj2 = {{\"type\", \"integer\"}, {\"version\", 1}};\n\n std::cout << std::boolalpha << (uj1 == uj2) << '\\n' << (oj1 == oj2) << std::endl;\n}\nOutput:
true\nfalse\nThe example demonstrates comparing several JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create several JSON values\n json array_1 = {1, 2, 3};\n json array_2 = {1, 2, 4};\n json object_1 = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json object_2 = {{\"B\", \"b\"}, {\"A\", \"a\"}};\n json number_1 = 17;\n json number_2 = 17.000000000000001L;\n json string_1 = \"foo\";\n json string_2 = \"bar\";\n\n // output values and comparisons\n std::cout << std::boolalpha;\n std::cout << array_1 << \" == \" << array_2 << \" \" << (array_1 == array_2) << '\\n';\n std::cout << object_1 << \" == \" << object_2 << \" \" << (object_1 == object_2) << '\\n';\n std::cout << number_1 << \" == \" << number_2 << \" \" << (number_1 == number_2) << '\\n';\n std::cout << string_1 << \" == \" << string_2 << \" \" << (string_1 == string_2) << '\\n';\n}\nOutput:
[1,2,3] == [1,2,4] false\n{\"A\":\"a\",\"B\":\"b\"} == {\"A\":\"a\",\"B\":\"b\"} true\n17 == 17.0 true\n\"foo\" == \"bar\" false\nThe example demonstrates comparing several JSON types against the null pointer (JSON null).
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create several JSON values\n json array = {1, 2, 3};\n json object = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json number = 17;\n json string = \"foo\";\n json null;\n\n // output values and comparisons\n std::cout << std::boolalpha;\n std::cout << array << \" == nullptr \" << (array == nullptr) << '\\n';\n std::cout << object << \" == nullptr \" << (object == nullptr) << '\\n';\n std::cout << number << \" == nullptr \" << (number == nullptr) << '\\n';\n std::cout << string << \" == nullptr \" << (string == nullptr) << '\\n';\n std::cout << null << \" == nullptr \" << (null == nullptr) << '\\n';\n}\nOutput:
[1,2,3] == nullptr false\n{\"A\":\"a\",\"B\":\"b\"} == nullptr false\n17 == nullptr false\n\"foo\" == nullptr false\nnull == nullptr true\n// until C++20\nbool operator>=(const_reference lhs, const_reference rhs) noexcept; // (1)\n\ntemplate<typename ScalarType>\nbool operator>=(const_reference lhs, const ScalarType rhs) noexcept; // (2)\n\ntemplate<typename ScalarType>\nbool operator>=(ScalarType lhs, const const_reference rhs) noexcept; // (2)\nCompares whether one JSON value lhs is greater than or equal to another JSON value rhs according to the following rules:
false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.!(lhs < rhs) (see operator<).Compares whether a JSON value is greater than or equal to a scalar or a scalar is greater than or equal to a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType a scalar type according to std::is_scalar<ScalarType>::value"},{"location":"api/basic_json/operator_ge/#parameters","title":"Parameters","text":"lhs (in) first value to consider rhs (in) second value to consider"},{"location":"api/basic_json/operator_ge/#return-value","title":"Return value","text":"whether lhs is greater than or equal to rhs
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/operator_ge/#complexity","title":"Complexity","text":"Linear.
"},{"location":"api/basic_json/operator_ge/#notes","title":"Notes","text":"Comparing NaN
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
The example demonstrates comparing several JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create several JSON values\n json array_1 = {1, 2, 3};\n json array_2 = {1, 2, 4};\n json object_1 = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json object_2 = {{\"B\", \"b\"}, {\"A\", \"a\"}};\n json number_1 = 17;\n json number_2 = 17.0000000000001L;\n json string_1 = \"foo\";\n json string_2 = \"bar\";\n\n // output values and comparisons\n std::cout << std::boolalpha;\n std::cout << array_1 << \" >= \" << array_2 << \" \" << (array_1 >= array_2) << '\\n';\n std::cout << object_1 << \" >= \" << object_2 << \" \" << (object_1 >= object_2) << '\\n';\n std::cout << number_1 << \" >= \" << number_2 << \" \" << (number_1 >= number_2) << '\\n';\n std::cout << string_1 << \" >= \" << string_2 << \" \" << (string_1 >= string_2) << '\\n';\n}\nOutput:
[1,2,3] >= [1,2,4] false\n{\"A\":\"a\",\"B\":\"b\"} >= {\"A\":\"a\",\"B\":\"b\"} true\n17 >= 17.0000000000001 false\n\"foo\" >= \"bar\" true\n// until C++20\nbool operator>(const_reference lhs, const_reference rhs) noexcept; // (1)\n\ntemplate<typename ScalarType>\nbool operator>(const_reference lhs, const ScalarType rhs) noexcept; // (2)\n\ntemplate<typename ScalarType>\nbool operator>(ScalarType lhs, const const_reference rhs) noexcept; // (2)\nCompares whether one JSON value lhs is greater than another JSON value rhs according to the following rules:
false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.!(lhs <= rhs) (see operator<=).Compares whether a JSON value is greater than a scalar or a scalar is greater than a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType a scalar type according to std::is_scalar<ScalarType>::value"},{"location":"api/basic_json/operator_gt/#parameters","title":"Parameters","text":"lhs (in) first value to consider rhs (in) second value to consider"},{"location":"api/basic_json/operator_gt/#return-value","title":"Return value","text":"whether lhs is greater than rhs
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/operator_gt/#complexity","title":"Complexity","text":"Linear.
"},{"location":"api/basic_json/operator_gt/#notes","title":"Notes","text":"Comparing NaN
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
The example demonstrates comparing several JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create several JSON values\n json array_1 = {1, 2, 3};\n json array_2 = {1, 2, 4};\n json object_1 = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json object_2 = {{\"B\", \"b\"}, {\"A\", \"a\"}};\n json number_1 = 17;\n json number_2 = 17.0000000000001L;\n json string_1 = \"foo\";\n json string_2 = \"bar\";\n\n // output values and comparisons\n std::cout << std::boolalpha;\n std::cout << array_1 << \" > \" << array_2 << \" \" << (array_1 > array_2) << '\\n';\n std::cout << object_1 << \" > \" << object_2 << \" \" << (object_1 > object_2) << '\\n';\n std::cout << number_1 << \" > \" << number_2 << \" \" << (number_1 > number_2) << '\\n';\n std::cout << string_1 << \" > \" << string_2 << \" \" << (string_1 > string_2) << '\\n';\n}\nOutput:
[1,2,3] > [1,2,4] false\n{\"A\":\"a\",\"B\":\"b\"} > {\"A\":\"a\",\"B\":\"b\"} false\n17 > 17.0000000000001 false\n\"foo\" > \"bar\" true\n// until C++20\nbool operator<=(const_reference lhs, const_reference rhs) noexcept; // (1)\n\ntemplate<typename ScalarType>\nbool operator<=(const_reference lhs, const ScalarType rhs) noexcept; // (2)\n\ntemplate<typename ScalarType>\nbool operator<=(ScalarType lhs, const const_reference rhs) noexcept; // (2)\nCompares whether one JSON value lhs is less than or equal to another JSON value rhs according to the following rules:
false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.!(rhs < lhs) (see operator<).Compares whether a JSON value is less than or equal to a scalar or a scalar is less than or equal to a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType a scalar type according to std::is_scalar<ScalarType>::value"},{"location":"api/basic_json/operator_le/#parameters","title":"Parameters","text":"lhs (in) first value to consider rhs (in) second value to consider"},{"location":"api/basic_json/operator_le/#return-value","title":"Return value","text":"whether lhs is less than or equal to rhs
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/operator_le/#complexity","title":"Complexity","text":"Linear.
"},{"location":"api/basic_json/operator_le/#notes","title":"Notes","text":"Comparing NaN
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
The example demonstrates comparing several JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create several JSON values\n json array_1 = {1, 2, 3};\n json array_2 = {1, 2, 4};\n json object_1 = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json object_2 = {{\"B\", \"b\"}, {\"A\", \"a\"}};\n json number_1 = 17;\n json number_2 = 17.0000000000001L;\n json string_1 = \"foo\";\n json string_2 = \"bar\";\n\n // output values and comparisons\n std::cout << std::boolalpha;\n std::cout << array_1 << \" <= \" << array_2 << \" \" << (array_1 <= array_2) << '\\n';\n std::cout << object_1 << \" <= \" << object_2 << \" \" << (object_1 <= object_2) << '\\n';\n std::cout << number_1 << \" <= \" << number_2 << \" \" << (number_1 <= number_2) << '\\n';\n std::cout << string_1 << \" <= \" << string_2 << \" \" << (string_1 <= string_2) << '\\n';\n}\nOutput:
[1,2,3] <= [1,2,4] true\n{\"A\":\"a\",\"B\":\"b\"} <= {\"A\":\"a\",\"B\":\"b\"} true\n17 <= 17.0000000000001 true\n\"foo\" <= \"bar\" false\n// until C++20\nbool operator<(const_reference lhs, const_reference rhs) noexcept; // (1)\n\ntemplate<typename ScalarType>\nbool operator<(const_reference lhs, const ScalarType rhs) noexcept; // (2)\n\ntemplate<typename ScalarType>\nbool operator<(ScalarType lhs, const const_reference rhs) noexcept; // (2)\nCompares whether one JSON value lhs is less than another JSON value rhs according to the following rules:
false.operator<.lhs and rhs have different types, the values are ignored and the order of the types is considered, which is:Compares whether a JSON value is less than a scalar or a scalar is less than a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType a scalar type according to std::is_scalar<ScalarType>::value"},{"location":"api/basic_json/operator_lt/#parameters","title":"Parameters","text":"lhs (in) first value to consider rhs (in) second value to consider"},{"location":"api/basic_json/operator_lt/#return-value","title":"Return value","text":"whether lhs is less than rhs
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/operator_lt/#complexity","title":"Complexity","text":"Linear.
"},{"location":"api/basic_json/operator_lt/#notes","title":"Notes","text":"Comparing NaN
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
The example demonstrates comparing several JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create several JSON values\n json array_1 = {1, 2, 3};\n json array_2 = {1, 2, 4};\n json object_1 = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json object_2 = {{\"B\", \"b\"}, {\"A\", \"a\"}};\n json number_1 = 17;\n json number_2 = 17.0000000000001L;\n json string_1 = \"foo\";\n json string_2 = \"bar\";\n\n // output values and comparisons\n std::cout << std::boolalpha;\n std::cout << array_1 << \" == \" << array_2 << \" \" << (array_1 < array_2) << '\\n';\n std::cout << object_1 << \" == \" << object_2 << \" \" << (object_1 < object_2) << '\\n';\n std::cout << number_1 << \" == \" << number_2 << \" \" << (number_1 < number_2) << '\\n';\n std::cout << string_1 << \" == \" << string_2 << \" \" << (string_1 < string_2) << '\\n';\n}\nOutput:
[1,2,3] == [1,2,4] true\n{\"A\":\"a\",\"B\":\"b\"} == {\"A\":\"a\",\"B\":\"b\"} false\n17 == 17.0000000000001 true\n\"foo\" == \"bar\" false\n// until C++20\nbool operator!=(const_reference lhs, const_reference rhs) noexcept; // (1)\n\ntemplate<typename ScalarType>\nbool operator!=(const_reference lhs, const ScalarType rhs) noexcept; // (2)\n\ntemplate<typename ScalarType>\nbool operator!=(ScalarType lhs, const const_reference rhs) noexcept; // (2)\n\n// since C++20\nclass basic_json {\n bool operator!=(const_reference rhs) const noexcept; // (1)\n\n template<typename ScalarType>\n bool operator!=(ScalarType rhs) const noexcept; // (2)\n};\nCompares two JSON values for inequality according to the following rules:
false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.!(lhs == rhs) (until C++20) or !(*this == rhs) (since C++20).Compares a JSON value and a scalar or a scalar and a JSON value for inequality by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType a scalar type according to std::is_scalar<ScalarType>::value"},{"location":"api/basic_json/operator_ne/#parameters","title":"Parameters","text":"lhs (in) first value to consider rhs (in) second value to consider"},{"location":"api/basic_json/operator_ne/#return-value","title":"Return value","text":"whether the values lhs/*this and rhs are not equal
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/operator_ne/#complexity","title":"Complexity","text":"Linear.
"},{"location":"api/basic_json/operator_ne/#notes","title":"Notes","text":"Comparing NaN
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
The example demonstrates comparing several JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create several JSON values\n json array_1 = {1, 2, 3};\n json array_2 = {1, 2, 4};\n json object_1 = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json object_2 = {{\"B\", \"b\"}, {\"A\", \"a\"}};\n json number_1 = 17;\n json number_2 = 17.000000000000001L;\n json string_1 = \"foo\";\n json string_2 = \"bar\";\n\n // output values and comparisons\n std::cout << std::boolalpha;\n std::cout << array_1 << \" != \" << array_2 << \" \" << (array_1 != array_2) << '\\n';\n std::cout << object_1 << \" != \" << object_2 << \" \" << (object_1 != object_2) << '\\n';\n std::cout << number_1 << \" != \" << number_2 << \" \" << (number_1 != number_2) << '\\n';\n std::cout << string_1 << \" != \" << string_2 << \" \" << (string_1 != string_2) << '\\n';\n}\nOutput:
[1,2,3] != [1,2,4] true\n{\"A\":\"a\",\"B\":\"b\"} != {\"A\":\"a\",\"B\":\"b\"} false\n17 != 17.0 false\n\"foo\" != \"bar\" true\nThe example demonstrates comparing several JSON types against the null pointer (JSON null).
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create several JSON values\n json array = {1, 2, 3};\n json object = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json number = 17;\n json string = \"foo\";\n json null;\n\n // output values and comparisons\n std::cout << std::boolalpha;\n std::cout << array << \" != nullptr \" << (array != nullptr) << '\\n';\n std::cout << object << \" != nullptr \" << (object != nullptr) << '\\n';\n std::cout << number << \" != nullptr \" << (number != nullptr) << '\\n';\n std::cout << string << \" != nullptr \" << (string != nullptr) << '\\n';\n std::cout << null << \" != nullptr \" << (null != nullptr) << '\\n';\n}\nOutput:
[1,2,3] != nullptr true\n{\"A\":\"a\",\"B\":\"b\"} != nullptr true\n17 != nullptr true\n\"foo\" != nullptr true\nnull != nullptr false\n// since C++20\nclass basic_json {\n std::partial_ordering operator<=>(const_reference rhs) const noexcept; // (1)\n\n template<typename ScalarType>\n std::partial_ordering operator<=>(const ScalarType rhs) const noexcept; // (2)\n};\n3-way compares two JSON values producing a result of type std::partial_ordering according to the following rules:
std::partial_ordering::unordered if either value is discarded.operator<=>.operator<=>. For instance, comparing an integer and a floating-point value will 3-way compare the first value converted to floating-point with the second value.value_t).3-way compares a JSON value and a scalar or a scalar and a JSON value by converting the scalar to a JSON value and 3-way comparing both JSON values (see 1).
ScalarType a scalar type according to std::is_scalar<ScalarType>::value"},{"location":"api/basic_json/operator_spaceship/#parameters","title":"Parameters","text":"rhs (in) second value to consider"},{"location":"api/basic_json/operator_spaceship/#return-value","title":"Return value","text":"the std::partial_ordering of the 3-way comparison of *this and rhs
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/operator_spaceship/#complexity","title":"Complexity","text":"Linear.
"},{"location":"api/basic_json/operator_spaceship/#notes","title":"Notes","text":"Comparing NaN
NaN values are unordered within the domain of numbers. The following comparisons all yield std::partial_ordering::unordered:NaN with itself.NaN with another NaN.NaN and any other number.The example demonstrates comparing several JSON values.
#include <compare>\n#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nconst char* to_string(const std::partial_ordering& po)\n{\n if (std::is_lt(po))\n {\n return \"less\";\n }\n else if (std::is_gt(po))\n {\n return \"greater\";\n }\n else if (std::is_eq(po))\n {\n return \"equivalent\";\n }\n return \"unordered\";\n}\n\nint main()\n{\n // create several JSON values\n json array_1 = {1, 2, 3};\n json array_2 = {1, 2, 4};\n json object_1 = {{\"A\", \"a\"}, {\"B\", \"b\"}};\n json object_2 = {{\"B\", \"b\"}, {\"A\", \"a\"}};\n json number = 17;\n json string = \"foo\";\n json discarded = json(json::value_t::discarded);\n\n // output values and comparisons\n std::cout << array_1 << \" <=> \" << array_2 << \" := \" << to_string(array_1 <=> array_2) << '\\n'; // *NOPAD*\n std::cout << object_1 << \" <=> \" << object_2 << \" := \" << to_string(object_1 <=> object_2) << '\\n'; // *NOPAD*\n std::cout << string << \" <=> \" << number << \" := \" << to_string(string <=> number) << '\\n'; // *NOPAD*\n std::cout << string << \" <=> \" << discarded << \" := \" << to_string(string <=> discarded) << '\\n'; // *NOPAD*\n}\nOutput:
[1,2,3] <=> [1,2,4] := less\n{\"A\":\"a\",\"B\":\"b\"} <=> {\"A\":\"a\",\"B\":\"b\"} := equivalent\n\"foo\" <=> 17 := greater\n\"foo\" <=> <discarded> := unordered\nThe example demonstrates comparing several JSON values and scalars.
#include <compare>\n#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nconst char* to_string(const std::partial_ordering& po)\n{\n if (std::is_lt(po))\n {\n return \"less\";\n }\n else if (std::is_gt(po))\n {\n return \"greater\";\n }\n else if (std::is_eq(po))\n {\n return \"equivalent\";\n }\n return \"unordered\";\n}\n\nint main()\n{\n using float_limits = std::numeric_limits<json::number_float_t>;\n constexpr auto nan = float_limits::quiet_NaN();\n\n // create several JSON values\n json boolean = false;\n json number = 17;\n json string = \"17\";\n\n // output values and comparisons\n std::cout << std::boolalpha << std::fixed;\n std::cout << boolean << \" <=> \" << true << \" := \" << to_string(boolean <=> true) << '\\n'; // *NOPAD*\n std::cout << number << \" <=> \" << 17.0 << \" := \" << to_string(number <=> 17.0) << '\\n'; // *NOPAD*\n std::cout << number << \" <=> \" << nan << \" := \" << to_string(number <=> nan) << '\\n'; // *NOPAD*\n std::cout << string << \" <=> \" << 17 << \" := \" << to_string(string <=> 17) << '\\n'; // *NOPAD*\n}\nOutput:
false <=> true := less\n17 <=> 17.000000 := equivalent\n17 <=> nan := unordered\n\"17\" <=> 17 := greater\nconstexpr operator value_t() const noexcept;\nReturn the type of the JSON value as a value from the value_t enumeration.
the type of the JSON value
Value type return valuenull value_t::null boolean value_t::boolean string value_t::string number (integer) value_t::number_integer number (unsigned integer) value_t::number_unsigned number (floating-point) value_t::number_float object value_t::object array value_t::array binary value_t::binary discarded value_t::discarded"},{"location":"api/basic_json/operator_value_t/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/operator_value_t/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/operator_value_t/#examples","title":"Examples","text":"ExampleThe following code exemplifies operator value_t() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = -17;\n json j_number_unsigned = 42u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n\n // call operator value_t()\n json::value_t t_null = j_null;\n json::value_t t_boolean = j_boolean;\n json::value_t t_number_integer = j_number_integer;\n json::value_t t_number_unsigned = j_number_unsigned;\n json::value_t t_number_float = j_number_float;\n json::value_t t_object = j_object;\n json::value_t t_array = j_array;\n json::value_t t_string = j_string;\n\n // print types\n std::cout << std::boolalpha;\n std::cout << (t_null == json::value_t::null) << '\\n';\n std::cout << (t_boolean == json::value_t::boolean) << '\\n';\n std::cout << (t_number_integer == json::value_t::number_integer) << '\\n';\n std::cout << (t_number_unsigned == json::value_t::number_unsigned) << '\\n';\n std::cout << (t_number_float == json::value_t::number_float) << '\\n';\n std::cout << (t_object == json::value_t::object) << '\\n';\n std::cout << (t_array == json::value_t::array) << '\\n';\n std::cout << (t_string == json::value_t::string) << '\\n';\n}\nOutput:
true\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\nclass other_error : public exception;\nThis exception is thrown in case of errors that cannot be classified with the other exception types.
Exceptions have ids 5xx (see list of other errors).
classDiagram\n direction LR\n\n class std_exception [\"std::exception\"] {\n <<interface>>\n }\n\n class json_exception [\"basic_json::exception\"] {\n +const int id\n +const char* what() const\n }\n\n class json_parse_error [\"basic_json::parse_error\"] {\n +const std::size_t byte\n }\n\n class json_invalid_iterator [\"basic_json::invalid_iterator\"]\n class json_type_error [\"basic_json::type_error\"]\n class json_out_of_range [\"basic_json::out_of_range\"]\n class json_other_error [\"basic_json::other_error\"]\n\n std_exception <|-- json_exception\n json_exception <|-- json_parse_error\n json_exception <|-- json_invalid_iterator\n json_exception <|-- json_type_error\n json_exception <|-- json_out_of_range\n json_exception <|-- json_other_error\n\n style json_other_error fill:#CCCCFFThe following code shows how a other_error exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n try\n {\n // executing a failing JSON Patch operation\n json value = R\"({\n \"best_biscuit\": {\n \"name\": \"Oreo\"\n }\n })\"_json;\n json patch = R\"([{\n \"op\": \"test\",\n \"path\": \"/best_biscuit/name\",\n \"value\": \"Choco Leibniz\"\n }])\"_json;\n value.patch(patch);\n }\n catch (const json::other_error& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.other_error.501] unsuccessful: {\"op\":\"test\",\"path\":\"/best_biscuit/name\",\"value\":\"Choco Leibniz\"}\nexception id: 501\nexception for the base class of all exceptions thrown by the libraryparse_error for exceptions indicating a parse errorinvalid_iterator for exceptions indicating errors with iteratorstype_error for exceptions indicating executing a member function with a wrong typeout_of_range for exceptions indicating access out of the defined rangeclass out_of_range : public exception;\nThis exception is thrown in case a library function is called on an input parameter that exceeds the expected range, for instance, in the case of array indices or nonexisting object keys.
Exceptions have ids 4xx (see list of out-of-range errors).
classDiagram\n direction LR\n\n class std_exception [\"std::exception\"] {\n <<interface>>\n }\n\n class json_exception [\"basic_json::exception\"] {\n +const int id\n +const char* what() const\n }\n\n class json_parse_error [\"basic_json::parse_error\"] {\n +const std::size_t byte\n }\n\n class json_invalid_iterator [\"basic_json::invalid_iterator\"]\n class json_type_error [\"basic_json::type_error\"]\n class json_out_of_range [\"basic_json::out_of_range\"]\n class json_other_error [\"basic_json::other_error\"]\n\n std_exception <|-- json_exception\n json_exception <|-- json_parse_error\n json_exception <|-- json_invalid_iterator\n json_exception <|-- json_type_error\n json_exception <|-- json_out_of_range\n json_exception <|-- json_other_error\n\n style json_out_of_range fill:#CCCCFFThe following code shows how a out_of_range exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // calling at() for an invalid index\n json j = {1, 2, 3, 4};\n j.at(4) = 10;\n }\n catch (const json::out_of_range& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.out_of_range.401] array index 4 is out of range\nexception id: 401\nexception for the base class of all exceptions thrown by the libraryparse_error for exceptions indicating a parse errorinvalid_iterator for exceptions indicating errors with iteratorstype_error for exceptions indicating executing a member function with a wrong typeother_error for exceptions indicating other library errors// (1)\ntemplate<typename InputType>\nstatic basic_json parse(InputType&& i,\n const parser_callback_t cb = nullptr,\n const bool allow_exceptions = true,\n const bool ignore_comments = false,\n const bool ignore_trailing_commas = false);\n\n// (2)\ntemplate<typename IteratorType>\nstatic basic_json parse(IteratorType first, IteratorType last,\n const parser_callback_t cb = nullptr,\n const bool allow_exceptions = true,\n const bool ignore_comments = false,\n const bool ignore_trailing_commas = false);\nDeserialize from a pair of character iterators
The value_type of the iterator must be an integral type with size of 1, 2, or 4 bytes, which will be interpreted respectively as UTF-8, UTF-16, and UTF-32.
InputType A compatible input, for instance:
std::istream objectFILE pointer (throws if null)std::stringobj for which begin(obj) and end(obj) produces a valid pair of iterators.IteratorType a compatible iterator type, for instance.
std::string::iterator or std::vector<std::uint8_t>::iteratorptr and ptr + leni (in) Input to parse from. cb (in) a parser callback function of type parser_callback_t which is used to control the deserialization by filtering unwanted values (optional) allow_exceptions (in) whether to throw exceptions in case of a parse error (optional, true by default) ignore_comments (in) whether comments should be ignored and treated like whitespace (true) or yield a parse error (false); (optional, false by default) ignore_trailing_commas (in) whether trailing commas in arrays or objects should be ignored and treated like whitespace (true) or yield a parse error (false); (optional, false by default) first (in) iterator to the start of a character range last (in) iterator to the end of a character range"},{"location":"api/basic_json/parse/#return-value","title":"Return value","text":"Deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/parse/#exceptions","title":"Exceptions","text":"parse_error.101 in case of an unexpected token, or empty input like a null FILE* or char* pointer.Linear in the length of the input. The parser is a predictive LL(1) parser. The complexity can be higher if the parser callback function cb or reading from (1) the input i or (2) the iterator range [first, last] has a super-linear complexity.
A UTF-8 byte order mark is silently ignored.
Invalid Unicode escapes and unpaired surrogates in the input are reported as parse_error.101 with a detailed message.
The example below demonstrates the parse() function reading from an array.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a JSON text\n char text[] = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, 38793]\n }\n }\n )\";\n\n // parse and serialize JSON\n json j_complete = json::parse(text);\n std::cout << std::setw(4) << j_complete << \"\\n\\n\";\n}\nOutput:
{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Thumbnail\": {\n \"Height\": 125,\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Width\": 100\n },\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\nThe example below demonstrates the parse() function with and without callback function.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, 38793]\n }\n }\n )\";\n\n // parse and serialize JSON\n json j_complete = json::parse(text);\n std::cout << std::setw(4) << j_complete << \"\\n\\n\";\n\n // define parser callback\n json::parser_callback_t cb = [](int depth, json::parse_event_t event, json & parsed)\n {\n // skip object elements with key \"Thumbnail\"\n if (event == json::parse_event_t::key and parsed == json(\"Thumbnail\"))\n {\n return false;\n }\n else\n {\n return true;\n }\n };\n\n // parse (with callback) and serialize JSON\n json j_filtered = json::parse(text, cb);\n std::cout << std::setw(4) << j_filtered << '\\n';\n}\nOutput:
{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Thumbnail\": {\n \"Height\": 125,\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Width\": 100\n },\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\n\n{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\nThe example below demonstrates the parse() function with and without callback function.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, 38793]\n }\n }\n )\";\n\n // fill a stream with JSON text\n std::stringstream ss;\n ss << text;\n\n // parse and serialize JSON\n json j_complete = json::parse(ss);\n std::cout << std::setw(4) << j_complete << \"\\n\\n\";\n\n // define parser callback\n json::parser_callback_t cb = [](int depth, json::parse_event_t event, json & parsed)\n {\n // skip object elements with key \"Thumbnail\"\n if (event == json::parse_event_t::key and parsed == json(\"Thumbnail\"))\n {\n return false;\n }\n else\n {\n return true;\n }\n };\n\n // fill a stream with JSON text\n ss.clear();\n ss << text;\n\n // parse (with callback) and serialize JSON\n json j_filtered = json::parse(ss, cb);\n std::cout << std::setw(4) << j_filtered << '\\n';\n}\nOutput:
{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Thumbnail\": {\n \"Height\": 125,\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Width\": 100\n },\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\n\n{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\nThe example below demonstrates the parse() function reading from a contiguous container.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a JSON text given as std::vector\n std::vector<std::uint8_t> text = {'[', '1', ',', '2', ',', '3', ']', '\\0'};\n\n // parse and serialize JSON\n json j_complete = json::parse(text);\n std::cout << std::setw(4) << j_complete << \"\\n\\n\";\n}\nOutput:
[\n 1,\n 2,\n 3\n]\nThe example below demonstrates the parse() function reading from a string that is not null-terminated.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a JSON text given as string that is not null-terminated\n const char* ptr = \"[1,2,3]another value\";\n\n // parse and serialize JSON\n json j_complete = json::parse(ptr, ptr + 7);\n std::cout << std::setw(4) << j_complete << \"\\n\\n\";\n}\nOutput:
[\n 1,\n 2,\n 3\n]\nThe example below demonstrates the parse() function reading from an iterator pair.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a JSON text given an input with other values\n std::vector<std::uint8_t> input = {'[', '1', ',', '2', ',', '3', ']', 'o', 't', 'h', 'e', 'r'};\n\n // parse and serialize JSON\n json j_complete = json::parse(input.begin(), input.begin() + 7);\n std::cout << std::setw(4) << j_complete << \"\\n\\n\";\n}\nOutput:
[\n 1,\n 2,\n 3\n]\nallow_exceptions parameter The example below demonstrates the effect of the allow_exceptions parameter in the parse() function.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // an invalid JSON text\n std::string text = R\"(\n {\n \"key\": \"value without closing quotes\n }\n )\";\n\n // parse with exceptions\n try\n {\n json j = json::parse(text);\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n // parse without exceptions\n json j = json::parse(text, nullptr, false);\n\n if (j.is_discarded())\n {\n std::cout << \"the input is invalid JSON\" << std::endl;\n }\n else\n {\n std::cout << \"the input is valid JSON: \" << j << std::endl;\n }\n}\nOutput:
[json.exception.parse_error.101] parse error at line 4, column 0: syntax error while parsing value - invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n; last read: '\"value without closing quotes<U+000A>'\nthe input is invalid JSON\nignore_comments parameter The example below demonstrates the effect of the ignore_comments parameter in the parse() function.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::string s = R\"(\n {\n // update in 2006: removed Pluto\n \"planets\": [\"Mercury\", \"Venus\", \"Earth\", \"Mars\",\n \"Jupiter\", \"Uranus\", \"Neptune\" /*, \"Pluto\" */]\n }\n )\";\n\n try\n {\n json j = json::parse(s);\n }\n catch (json::exception& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n json j = json::parse(s,\n /* callback */ nullptr,\n /* allow exceptions */ true,\n /* ignore_comments */ true);\n std::cout << j.dump(2) << '\\n';\n}\nOutput:
[json.exception.parse_error.101] parse error at line 3, column 9: syntax error while parsing object key - invalid literal; last read: '<U+000A> {<U+000A> /'; expected string literal\n{\n \"planets\": [\n \"Mercury\",\n \"Venus\",\n \"Earth\",\n \"Mars\",\n \"Jupiter\",\n \"Uranus\",\n \"Neptune\"\n ]\n}\nignore_trailing_commas parameter The example below demonstrates the effect of the ignore_trailing_commas parameter in the parse() function.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::string s = R\"(\n {\n \"planets\": [\n \"Mercury\",\n \"Venus\",\n \"Earth\",\n \"Mars\",\n \"Jupiter\",\n \"Uranus\",\n \"Neptune\",\n ]\n }\n )\";\n\n try\n {\n json j = json::parse(s);\n }\n catch (json::exception& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n json j = json::parse(s,\n /* callback */ nullptr,\n /* allow exceptions */ true,\n /* ignore_comments */ false,\n /* ignore_trailing_commas */ true);\n std::cout << j.dump(2) << '\\n';\n}\nOutput:
[json.exception.parse_error.101] parse error at line 11, column 9: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal\n{\n \"planets\": [\n \"Mercury\",\n \"Venus\",\n \"Earth\",\n \"Mars\",\n \"Jupiter\",\n \"Uranus\",\n \"Neptune\"\n ]\n}\nignore_comments added in version 3.9.0.FILE* null pointers to exception in version 3.12.0.ignore_trailing_commas in version 3.12.x.Deprecation
Overload (2) replaces calls to parse with a pair of iterators as their first parameter which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like parse({ptr, ptr+len}, ...); with parse(ptr, ptr+len, ...);.
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
class parse_error : public exception;\nThe library throws this exception when a parse error occurs. Parse errors can occur during the deserialization of JSON text, BSON, CBOR, MessagePack, UBJSON, as well as when using JSON Patch.
Member byte holds the byte index of the last read character in the input file (see note below).
Exceptions have ids 1xx (see list of parse errors).
classDiagram\n direction LR\n\n class std_exception [\"std::exception\"] {\n <<interface>>\n }\n\n class json_exception [\"basic_json::exception\"] {\n +const int id\n +const char* what() const\n }\n\n class json_parse_error [\"basic_json::parse_error\"] {\n +const std::size_t byte\n }\n\n class json_invalid_iterator [\"basic_json::invalid_iterator\"]\n class json_type_error [\"basic_json::type_error\"]\n class json_out_of_range [\"basic_json::out_of_range\"]\n class json_other_error [\"basic_json::other_error\"]\n\n std_exception <|-- json_exception\n json_exception <|-- json_parse_error\n json_exception <|-- json_invalid_iterator\n json_exception <|-- json_type_error\n json_exception <|-- json_out_of_range\n json_exception <|-- json_other_error\n\n style json_parse_error fill:#CCCCFFFor an input with n bytes, 1 is the index of the first character and n+1 is the index of the terminating null byte or the end of file. This also holds true when reading a byte vector for binary formats.
"},{"location":"api/basic_json/parse_error/#examples","title":"Examples","text":"ExampleThe following code shows how a parse_error exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // parsing input with a syntax error\n json::parse(\"[1,2,3,]\");\n }\n catch (const json::parse_error& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << '\\n'\n << \"byte position of error: \" << e.byte << std::endl;\n }\n}\nOutput:
message: [json.exception.parse_error.101] parse error at line 1, column 8: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal\nexception id: 101\nbyte position of error: 8\nexception for the base class of all exceptions thrown by the libraryinvalid_iterator for exceptions indicating errors with iteratorstype_error for exceptions indicating executing a member function with a wrong typeout_of_range for exceptions indicating access out of the defined rangeother_error for exceptions indicating other library errorsenum class parse_event_t : std::uint8_t {\n object_start,\n object_end,\n array_start,\n array_end,\n key,\n value\n};\nThe parser callback distinguishes the following events:
object_start: the parser read { and started to process a JSON objectkey: the parser read a key of a value in an objectobject_end: the parser read } and finished processing a JSON objectarray_start: the parser read [ and started to process a JSON arrayarray_end: the parser read ] and finished processing a JSON arrayvalue: the parser finished reading a JSON valuetemplate<typename BasicJsonType>\nusing parser_callback_t =\n std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;\nWith a parser callback function, the result of parsing a JSON text can be influenced. When passed to parse, it is called on certain events (passed as parse_event_t via parameter event) with a set recursion depth depth and context JSON value parsed. The return value of the callback function is a boolean indicating whether the element that emitted the callback shall be kept or not.
We distinguish six scenarios (determined by the event type) in which the callback function can be called. The following table describes the values of the parameters depth, event, and parsed.
event description parameter depth parameter parsed parse_event_t::object_start the parser read { and started to process a JSON object depth of the parent of the JSON object a JSON value with type discarded parse_event_t::key the parser read a key of a value in an object depth of the currently parsed JSON object a JSON string containing the key parse_event_t::object_end the parser read } and finished processing a JSON object depth of the parent of the JSON object the parsed JSON object parse_event_t::array_start the parser read [ and started to process a JSON array depth of the parent of the JSON array a JSON value with type discarded parse_event_t::array_end the parser read ] and finished processing a JSON array depth of the parent of the JSON array the parsed JSON array parse_event_t::value the parser finished reading a JSON value depth of the value the parsed JSON value Discarding a value (i.e., returning false) has different effects depending on the context in which function was called:
null. This case happens if the top-level element is skipped.depth (in) the depth of the recursion during parsing event (in) an event of type parse_event_t indicating the context in the callback function has been called parsed (in, out) the current intermediate parse result; note that writing to this value has no effect for parse_event_t::key events"},{"location":"api/basic_json/parser_callback_t/#return-value","title":"Return value","text":"Whether the JSON value which called the function during parsing should be kept (true) or not (false). In the latter case, it is either skipped completely or replaced by an empty discarded object.
The example below demonstrates the parse() function with and without callback function.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, 38793]\n }\n }\n )\";\n\n // parse and serialize JSON\n json j_complete = json::parse(text);\n std::cout << std::setw(4) << j_complete << \"\\n\\n\";\n\n // define parser callback\n json::parser_callback_t cb = [](int depth, json::parse_event_t event, json & parsed)\n {\n // skip object elements with key \"Thumbnail\"\n if (event == json::parse_event_t::key and parsed == json(\"Thumbnail\"))\n {\n return false;\n }\n else\n {\n return true;\n }\n };\n\n // parse (with callback) and serialize JSON\n json j_filtered = json::parse(text, cb);\n std::cout << std::setw(4) << j_filtered << '\\n';\n}\nOutput:
{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Thumbnail\": {\n \"Height\": 125,\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Width\": 100\n },\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\n\n{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\nbasic_json patch(const basic_json& json_patch) const;\nJSON Patch defines a JSON document structure for expressing a sequence of operations to apply to a JSON document. With this function, a JSON Patch is applied to the current JSON value by executing all operations from the patch.
"},{"location":"api/basic_json/patch/#parameters","title":"Parameters","text":"json_patch (in) JSON patch document"},{"location":"api/basic_json/patch/#return-value","title":"Return value","text":"patched document
"},{"location":"api/basic_json/patch/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/patch/#exceptions","title":"Exceptions","text":"parse_error.104 if the JSON patch does not consist of an array of objects.parse_error.105 if the JSON patch is malformed (e.g., mandatory attributes are missing); example: \"operation add must have member path\".out_of_range.401 if an array index is out of range.out_of_range.403 if a JSON pointer inside the patch could not be resolved successfully in the current JSON value; example: \"key baz not found\".out_of_range.405 if JSON pointer has no parent (\"add\", \"remove\", \"move\")out_of_range.411 if an \"add\" operation's target location has a parent that is neither an object nor an array.other_error.501 if \"test\" operation was unsuccessful.Linear in the size of the JSON value and the length of the JSON patch. As usually the patch affects only a fraction of the JSON value, the complexity can usually be neglected.
"},{"location":"api/basic_json/patch/#notes","title":"Notes","text":"The application of a patch is atomic: Either all operations succeed and the patched document is returned or an exception is thrown. In any case, the original value is not changed: the patch is applied to a copy of the value.
"},{"location":"api/basic_json/patch/#examples","title":"Examples","text":"ExampleThe following code shows how a JSON patch is applied to a value.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // the original document\n json doc = R\"(\n {\n \"baz\": \"qux\",\n \"foo\": \"bar\"\n }\n )\"_json;\n\n // the patch\n json patch = R\"(\n [\n { \"op\": \"replace\", \"path\": \"/baz\", \"value\": \"boo\" },\n { \"op\": \"add\", \"path\": \"/hello\", \"value\": [\"world\"] },\n { \"op\": \"remove\", \"path\": \"/foo\"}\n ]\n )\"_json;\n\n // apply the patch\n json patched_doc = doc.patch(patch);\n\n // output original and patched document\n std::cout << std::setw(4) << doc << \"\\n\\n\"\n << std::setw(4) << patched_doc << std::endl;\n}\nOutput:
{\n \"baz\": \"qux\",\n \"foo\": \"bar\"\n}\n\n{\n \"baz\": \"boo\",\n \"hello\": [\n \"world\"\n ]\n}\nout_of_range.411 and stopped relying on an internal assertion when an \"add\" operation's target location has a non-object/non-array parent in version 3.12.x.void patch_inplace(const basic_json& json_patch);\nJSON Patch defines a JSON document structure for expressing a sequence of operations to apply to a JSON document. With this function, a JSON Patch is applied to the current JSON value by executing all operations from the patch. This function applies a JSON patch in place and returns void.
"},{"location":"api/basic_json/patch_inplace/#parameters","title":"Parameters","text":"json_patch (in) JSON patch document"},{"location":"api/basic_json/patch_inplace/#exception-safety","title":"Exception safety","text":"No guarantees, value may be corrupted by an unsuccessful patch operation.
"},{"location":"api/basic_json/patch_inplace/#exceptions","title":"Exceptions","text":"parse_error.104 if the JSON patch does not consist of an array of objects.parse_error.105 if the JSON patch is malformed (e.g., mandatory attributes are missing); example: \"operation add must have member path\".out_of_range.401 if an array index is out of range.out_of_range.403 if a JSON pointer inside the patch could not be resolved successfully in the current JSON value; example: \"key baz not found\".out_of_range.405 if JSON pointer has no parent (\"add\", \"remove\", \"move\")out_of_range.411 if an \"add\" operation's target location has a parent that is neither an object nor an array.other_error.501 if \"test\" operation was unsuccessful.Linear in the size of the JSON value and the length of the JSON patch. As usually the patch affects only a fraction of the JSON value, the complexity can usually be neglected.
"},{"location":"api/basic_json/patch_inplace/#notes","title":"Notes","text":"Unlike patch, patch_inplace applies the operation \"in place\" and no copy of the JSON value is created. That makes it faster for large documents by avoiding the copy. However, the JSON value might be corrupted if the function throws an exception.
The following code shows how a JSON patch is applied to a value.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // the original document\n json doc = R\"(\n {\n \"baz\": \"qux\",\n \"foo\": \"bar\"\n }\n )\"_json;\n\n // the patch\n json patch = R\"(\n [\n { \"op\": \"replace\", \"path\": \"/baz\", \"value\": \"boo\" },\n { \"op\": \"add\", \"path\": \"/hello\", \"value\": [\"world\"] },\n { \"op\": \"remove\", \"path\": \"/foo\"}\n ]\n )\"_json;\n\n // output original document\n std::cout << \"Before\\n\" << std::setw(4) << doc << std::endl;\n\n // apply the patch\n doc.patch_inplace(patch);\n\n // output patched document\n std::cout << \"\\nAfter\\n\" << std::setw(4) << doc << std::endl;\n}\nOutput:
Before\n{\n \"baz\": \"qux\",\n \"foo\": \"bar\"\n}\n\nAfter\n{\n \"baz\": \"boo\",\n \"hello\": [\n \"world\"\n ]\n}\nout_of_range.411 and stopped relying on an internal assertion when an \"add\" operation's target location has a non-object/non-array parent in version 3.12.x.// (1)\nvoid push_back(basic_json&& val);\nvoid push_back(const basic_json& val);\n\n// (2)\nvoid push_back(const typename object_t::value_type& val);\n\n// (3)\nvoid push_back(initializer_list_t init);\nAppends the given element val to the end of the JSON array. If the function is called on a JSON null value, an empty array is created before appending val.
Inserts the given element val to the JSON object. If the function is called on a JSON null value, an empty object is created before inserting val.
This function allows using push_back with an initializer list. In case
init contains only two elements, andinit is a string,init is converted into an object element and added using push_back(const typename object_t::value_type&). Otherwise, init is converted to a JSON value and added using push_back(basic_json&&).
For all cases where an element is added to an array, a reallocation can happen, in which case all iterators (including the end() iterator) and all references to the elements are invalidated. Otherwise, only the end() iterator is invalidated.
For ordered_json, also adding an element to an object can yield a reallocation which again invalidates all iterators and all references.
val (in) the value to add to the JSON array/object init (in) an initializer list"},{"location":"api/basic_json/push_back/#exceptions","title":"Exceptions","text":"type_error.308 when called on a type other than JSON array or null; example: \"cannot use push_back() with number\"type_error.308 when called on a type other than JSON object or null; example: \"cannot use push_back() with number\"type_error.308 when called on a type other than JSON array or null; example: \"cannot use push_back() with number\"size())).init.(3) This function is required to resolve an ambiguous overload error, because pairs like {\"key\", \"value\"} can be both interpreted as object_t::value_type or std::initializer_list<basic_json>, see #235 for more information.
The example shows how push_back() and += can be used to add elements to a JSON array. Note how the null value was silently converted to a JSON array.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json array = {1, 2, 3, 4, 5};\n json null;\n\n // print values\n std::cout << array << '\\n';\n std::cout << null << '\\n';\n\n // add values\n array.push_back(6);\n array += 7;\n null += \"first\";\n null += \"second\";\n\n // print values\n std::cout << array << '\\n';\n std::cout << null << '\\n';\n}\nOutput:
[1,2,3,4,5]\nnull\n[1,2,3,4,5,6,7]\n[\"first\",\"second\"]\nThe example shows how push_back() and += can be used to add elements to a JSON object. Note how the null value was silently converted to a JSON object.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json object = {{\"one\", 1}, {\"two\", 2}};\n json null;\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n\n // add values\n object.push_back(json::object_t::value_type(\"three\", 3));\n object += json::object_t::value_type(\"four\", 4);\n null += json::object_t::value_type(\"A\", \"a\");\n null += json::object_t::value_type(\"B\", \"b\");\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n}\nOutput:
{\"one\":1,\"two\":2}\nnull\n{\"four\":4,\"one\":1,\"three\":3,\"two\":2}\n{\"A\":\"a\",\"B\":\"b\"}\nThe example shows how initializer lists are treated as objects when possible.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json object = {{\"one\", 1}, {\"two\", 2}};\n json null;\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n\n // add values:\n object.push_back({\"three\", 3}); // object is extended\n object += {\"four\", 4}; // object is extended\n null.push_back({\"five\", 5}); // null is converted to array\n\n // print values\n std::cout << object << '\\n';\n std::cout << null << '\\n';\n\n // would throw:\n //object.push_back({1, 2, 3});\n}\nOutput:
{\"one\":1,\"two\":2}\nnull\n{\"four\":4,\"one\":1,\"three\":3,\"two\":2}\n[[\"five\",5]]\nreverse_iterator rbegin() noexcept;\nconst_reverse_iterator rbegin() const noexcept;\nReturns an iterator to the reverse-beginning; that is, the last element.
"},{"location":"api/basic_json/rbegin/#return-value","title":"Return value","text":"reverse iterator to the last element
"},{"location":"api/basic_json/rbegin/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/rbegin/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/rbegin/#examples","title":"Examples","text":"ExampleThe following code shows an example for rbegin().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array value\n json array = {1, 2, 3, 4, 5};\n\n // get an iterator to the reverse-beginning\n json::reverse_iterator it = array.rbegin();\n\n // serialize the element that the iterator points to\n std::cout << *it << '\\n';\n}\nOutput:
5\nreverse_iterator rend() noexcept;\nconst_reverse_iterator rend() const noexcept;\nReturns an iterator to the reverse-end; that is, one before the first element. This element acts as a placeholder, attempting to access it results in undefined behavior.
"},{"location":"api/basic_json/rend/#return-value","title":"Return value","text":"reverse iterator to the element following the last element
"},{"location":"api/basic_json/rend/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/rend/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/rend/#examples","title":"Examples","text":"ExampleThe following code shows an example for rend().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create an array value\n json array = {1, 2, 3, 4, 5};\n\n // get an iterator to the reverse-end\n json::reverse_iterator it = array.rend();\n\n // increment the iterator to point to the first element\n --it;\n\n // serialize the element that the iterator points to\n std::cout << *it << '\\n';\n}\nOutput:
1\n// (1)\ntemplate <typename InputType, typename SAX>\nstatic bool sax_parse(InputType&& i,\n SAX* sax,\n input_format_t format = input_format_t::json,\n const bool strict = true,\n const bool ignore_comments = false,\n const bool ignore_trailing_commas = false);\n\n// (2)\ntemplate<class IteratorType, class SAX>\nstatic bool sax_parse(IteratorType first, IteratorType last,\n SAX* sax,\n input_format_t format = input_format_t::json,\n const bool strict = true,\n const bool ignore_comments = false,\n const bool ignore_trailing_commas = false);\nRead from input and generate SAX events
Read from a pair of character iterators
The value_type of the iterator must be an integral type with a size of 1, 2, or 4 bytes, which will be interpreted respectively as UTF-8, UTF-16, and UTF-32.
The SAX event lister must follow the interface of json_sax.
InputType A compatible input, for instance:
std::istream objectFILE pointerobj for which begin(obj) and end(obj) produces a valid pair of iterators.IteratorType a compatible iterator type for overload (2); a pair of character iterators whose value_type is an integral type with a size of 1, 2, or 4 bytes (interpreted respectively as UTF-8, UTF-16, and UTF-32) SAX a class fulfilling the SAX event listener interface; see json_sax"},{"location":"api/basic_json/sax_parse/#parameters","title":"Parameters","text":"i (in) Input to parse from sax (in) SAX event listener (must not be null) format (in) the format to parse (JSON, CBOR, MessagePack, or UBJSON) (optional, input_format_t::json by default), see input_format_t for more information strict (in) whether the input has to be consumed completely (optional, true by default) ignore_comments (in) whether comments should be ignored and treated like whitespace (true) or yield a parse error (false); (optional, false by default) ignore_trailing_commas (in) whether trailing commas in arrays or objects should be ignored and treated like whitespace (true) or yield a parse error (false); (optional, false by default) first (in) iterator to the start of a character range last (in) iterator to the end of a character range"},{"location":"api/basic_json/sax_parse/#return-value","title":"Return value","text":"return value of the last processed SAX event
"},{"location":"api/basic_json/sax_parse/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/sax_parse/#exceptions","title":"Exceptions","text":"parse_error.101 in case of an unexpected token, or empty input like a null FILE* or char* pointer.Linear in the length of the input. The parser is a predictive LL(1) parser. The complexity can be higher if the SAX consumer sax has a super-linear complexity.
A UTF-8 byte order mark is silently ignored.
"},{"location":"api/basic_json/sax_parse/#examples","title":"Examples","text":"ExampleThe example below demonstrates the sax_parse() function reading from string and processing the events with a user-defined SAX event consumer.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nignore_comments added in version 3.9.0.ignore_trailing_commas in version 3.12.x.Deprecation
Overload (2) replaces calls to sax_parse with a pair of iterators as their first parameter which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like sax_parse({ptr, ptr+len}); with sax_parse(ptr, ptr+len);.
size_type size() const noexcept;\nReturns the number of elements in a JSON value.
"},{"location":"api/basic_json/size/#return-value","title":"Return value","text":"The return value depends on the different types and is defined as follows:
Value type return value null0 boolean 1 string 1 number 1 binary 1 object result of function object_t::size() array result of function array_t::size()"},{"location":"api/basic_json/size/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/size/#complexity","title":"Complexity","text":"Constant, as long as array_t and object_t satisfy the Container concept; that is, their size() functions have constant complexity.
This function does not return the length of a string stored as JSON value -- it returns the number of elements in the JSON value which is 1 in the case of a string.
The following code calls size() on the different value types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = 17;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_object_empty(json::value_t::object);\n json j_array = {1, 2, 4, 8, 16};\n json j_array_empty(json::value_t::array);\n json j_string = \"Hello, world\";\n\n // call size()\n std::cout << j_null.size() << '\\n';\n std::cout << j_boolean.size() << '\\n';\n std::cout << j_number_integer.size() << '\\n';\n std::cout << j_number_float.size() << '\\n';\n std::cout << j_object.size() << '\\n';\n std::cout << j_object_empty.size() << '\\n';\n std::cout << j_array.size() << '\\n';\n std::cout << j_array_empty.size() << '\\n';\n std::cout << j_string.size() << '\\n';\n}\nOutput:
0\n1\n1\n1\n2\n0\n5\n0\n1\n1 for binary types in version 3.8.0.#if JSON_DIAGNOSTIC_POSITIONS\nconstexpr std::size_t start_pos() const noexcept;\n#endif\nReturns the position of the first character in the JSON string from which the value was parsed from.
JSON type return value object position of the opening{ array position of the opening [ string position of the opening \" number position of the first character boolean position of t for true and f for false null position of n"},{"location":"api/basic_json/start_pos/#return-value","title":"Return value","text":"the position of the first character of the value in the parsed JSON string, if the value was created by the parse function, or std::string::npos if the value was constructed otherwise
No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/start_pos/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/start_pos/#notes","title":"Notes","text":"Note
The function is only available if macro JSON_DIAGNOSTIC_POSITIONS has been defined to 1 before including the library header.
Invalidation
The returned positions are only valid as long as the JSON value is not changed. The positions are not updated when the JSON value is changed.
"},{"location":"api/basic_json/start_pos/#examples","title":"Examples","text":"Example#include <iostream>\n\n#define JSON_DIAGNOSTIC_POSITIONS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::string json_string = R\"(\n {\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\n )\";\n json j = json::parse(json_string);\n\n std::cout << \"Root diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos: \" << j.start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j.end_pos() << \"\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"{\\n \\\"address\\\": {\\n \\\"street\\\": \\\"Fake Street\\\",\\n \\\"housenumber\\\": 1\\n }\\n }\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j.start_pos(), j.end_pos() - j.start_pos()) << \"\\n\\n\";\n\n std::cout << \"address diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"{ \\\"street\\\": \\\"Fake Street\\\",\\n \\\"housenumber\\\": 1\\n }\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"].start_pos(), j[\"address\"].end_pos() - j[\"address\"].start_pos()) << \"\\n\\n\";\n\n std::cout << \"street diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"][\"street\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"][\"street\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"\\\"Fake Street\\\"\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"][\"street\"].start_pos(), j[\"address\"][\"street\"].end_pos() - j[\"address\"][\"street\"].start_pos()) << \"\\n\\n\";\n\n std::cout << \"housenumber diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"][\"housenumber\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"][\"housenumber\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"1\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"][\"housenumber\"].start_pos(), j[\"address\"][\"housenumber\"].end_pos() - j[\"address\"][\"housenumber\"].start_pos()) << \"\\n\\n\";\n}\nOutput:
Root diagnostic positions: \n start_pos: 5\n end_pos:109\nOriginal string: \n{\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\nParsed string: \n{\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\n\naddress diagnostic positions: \n start_pos:26\n end_pos:103\n\nOriginal string: \n{ \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\nParsed string: \n{\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n\nstreet diagnostic positions: \n start_pos:50\n end_pos:63\n\nOriginal string: \n\"Fake Street\"\nParsed string: \n\"Fake Street\"\n\nhousenumber diagnostic positions: \n start_pos:92\n end_pos:93\n\nOriginal string: \n1\nParsed string: \n1\nThe output shows the start/end positions of all the objects and fields in the JSON string.
"},{"location":"api/basic_json/start_pos/#see-also","title":"See also","text":"namespace std {\n template <>\n struct formatter<nlohmann::basic_json, char>;\n}\nSpecialization to make JSON values formattable with std::format (and the other members of C++20's <format> header, such as std::format_to).
A subset of the standard format spec grammar is supported, repurposed for JSON pretty-printing; any other spec component (sign, the 0 flag, precision, L, a dynamic width such as \"{:{}}\", or a trailing type character) throws std::format_error:
\"{}\" serializes the value the same way as dump() (compact, no whitespace).\"{:#}\" (\"alternate form\") serializes the value the same way as dump(4) (pretty-printed with an indent of 4).\"#\" (e.g. \"{:2}\" or \"{:#2}\"), serializes the value the same way as dump(width) \u2014 a width on its own implies pretty-printing, since an indent size has no meaning for compact output.fill-and-align (e.g. \"{:.>#}\" or \"{:.>3}\") picks a custom indent character, the same way as dump(indent, indent_char). The alignment direction itself ('<', '>', '^') has no separate meaning for JSON values \u2014 only the fill character before it is used, and any of the three directions is accepted.This specialization is only available for char-based JSON values and only if the standard library provides <format>, controlled by the JSON_HAS_STD_FORMAT macro.
The example shows how to format JSON values with std::format.
#include <format>\n#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j = {{\"one\", 1}, {\"two\", 2}};\n\n // compact formatting, like dump()\n std::cout << std::format(\"{}\", j) << \"\\n\\n\";\n\n // pretty-printed formatting, like dump(4)\n std::cout << std::format(\"{:#}\", j) << \"\\n\\n\";\n\n // a width sets the indent, like dump(2)\n std::cout << std::format(\"{:2}\", j) << \"\\n\\n\";\n\n // fill-and-align sets the indent character, like dump(4, '.')\n std::cout << std::format(\"{:.>#}\", j) << std::endl;\n}\nOutput:
{\"one\":1,\"two\":2}\n\n{\n \"one\": 1,\n \"two\": 2\n}\n\n{\n \"one\": 1,\n \"two\": 2\n}\n\n{\n....\"one\": 1,\n....\"two\": 2\n}\nfmt::format (fmtlib)namespace std {\n struct hash<nlohmann::basic_json>;\n}\nReturn a hash value for a JSON object. The hash function tries to rely on std::hash where possible. Furthermore, the type of the JSON value is taken into account to have different hash values for null, 0, 0U, and false, etc.
The example shows how to calculate hash values for different JSON values.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n std::cout << \"hash(null) = \" << std::hash<json> {}(json(nullptr)) << '\\n'\n << \"hash(false) = \" << std::hash<json> {}(json(false)) << '\\n'\n << \"hash(0) = \" << std::hash<json> {}(json(0)) << '\\n'\n << \"hash(0U) = \" << std::hash<json> {}(json(0U)) << '\\n'\n << \"hash(\\\"\\\") = \" << std::hash<json> {}(json(\"\")) << '\\n'\n << \"hash({}) = \" << std::hash<json> {}(json::object()) << '\\n'\n << \"hash([]) = \" << std::hash<json> {}(json::array()) << '\\n'\n << \"hash({\\\"hello\\\": \\\"world\\\"}) = \" << std::hash<json> {}(\"{\\\"hello\\\": \\\"world\\\"}\"_json)\n << std::endl;\n}\nOutput:
hash(null) = 2654435769\nhash(false) = 2654436030\nhash(0) = 2654436095\nhash(0U) = 2654436156\nhash(\"\") = 6142509191626859748\nhash({}) = 2654435832\nhash([]) = 2654435899\nhash({\"hello\": \"world\"}) = 4469488738203676328\nNote the output is platform-dependent.
"},{"location":"api/basic_json/std_hash/#version-history","title":"Version history","text":"namespace std {\n void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2);\n}\nExchanges the values of two JSON objects.
"},{"location":"api/basic_json/std_swap/#parameters","title":"Parameters","text":"j1 (in, out) value to be replaced by j2 j2 (in, out) value to be replaced by j1"},{"location":"api/basic_json/std_swap/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this function never throws exceptions.
"},{"location":"api/basic_json/std_swap/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/std_swap/#possible-implementation","title":"Possible implementation","text":"void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2)\n{\n j1.swap(j2);\n}\nThe following code shows how two values are swapped with std::swap.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j1 = {{\"one\", 1}, {\"two\", 2}};\n json j2 = {1, 2, 4, 8, 16};\n\n std::cout << \"j1 = \" << j1 << \" | j2 = \" << j2 << '\\n';\n\n // swap values\n std::swap(j1, j2);\n\n std::cout << \"j1 = \" << j1 << \" | j2 = \" << j2 << std::endl;\n}\nOutput:
j1 = {\"one\":1,\"two\":2} | j2 = [1,2,4,8,16]\nj1 = [1,2,4,8,16] | j2 = {\"one\":1,\"two\":2}\nusing string_t = StringType;\nThe type used to store JSON strings.
RFC 8259 describes JSON strings as follows:
A string is a sequence of zero or more Unicode characters.
To store strings in C++, a type is defined by the template parameter described below. Unicode values are split by the JSON class into byte-sized characters during deserialization.
"},{"location":"api/basic_json/string_t/#template-parameters","title":"Template parameters","text":"StringType the container to store strings (e.g., std::string). Note this container is used for keys/names in objects, see object_t."},{"location":"api/basic_json/string_t/#notes","title":"Notes","text":""},{"location":"api/basic_json/string_t/#default-type","title":"Default type","text":"With the default values for StringType (std::string), the default value for string_t is std::string.
Strings are stored in UTF-8 encoding. Therefore, functions like std::string::size() or std::string::length() return the number of bytes in the string rather than the number of characters or glyphs.
RFC 8259 states:
Software implementations are typically required to test names of object members for equality. Implementations that transform the textual representation into sequences of Unicode code units and then perform the comparison numerically, code unit by code unit, are interoperable in the sense that implementations will agree in all cases on equality or inequality of two strings. For example, implementations that compare strings with escaped characters unconverted may incorrectly find that \"a\\\\b\" and \"a\\u005Cb\" are not equal.
This implementation is interoperable as it does compare strings code unit by code unit.
"},{"location":"api/basic_json/string_t/#storage","title":"Storage","text":"String values are stored as pointers in a basic_json type. That is, for any access to string values, a pointer of type string_t* must be dereferenced.
basic_json conversion requirements","text":"When converting a string value from one basic_json specialization to another via the converting constructor, the target string_t must be directly constructible from the source basic_json's string_t type. If this requirement is not met, the conversion does not fail; instead, the string is silently converted as an array of character codes, which is incorrect. See issue #3425 for details and an example.
The following code shows that string_t is by default, a typedef to std::string.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::boolalpha << std::is_same<std::string, json::string_t>::value << std::endl;\n}\nOutput:
true\n// (1)\nvoid swap(reference other) noexcept (\n std::is_nothrow_move_constructible<value_t>::value &&\n std::is_nothrow_move_assignable<value_t>::value &&\n std::is_nothrow_move_constructible<json_value>::value &&\n std::is_nothrow_move_assignable<json_value>::value\n);\n\n// (2)\nfriend void swap(reference left, reference right) noexcept (\n std::is_nothrow_move_constructible<value_t>::value &&\n std::is_nothrow_move_assignable<value_t>::value &&\n std::is_nothrow_move_constructible<json_value>::value &&\n std::is_nothrow_move_assignable<json_value>::value\n);\n\n// (3)\nvoid swap(array_t& other);\n\n// (4)\nvoid swap(object_t& other);\n\n// (5)\nvoid swap(string_t& other);\n\n// (6)\nvoid swap(binary_t& other);\n\n// (7)\nvoid swap(typename binary_t::container_type& other);\nother. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. left with those of right. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. Implemented as a friend function callable via ADL.other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. Unlike version (6), no binary subtype is involved.other (in, out) value to exchange the contents with left (in, out) value to exchange the contents with right (in, out) value to exchange the contents with"},{"location":"api/basic_json/swap/#exceptions","title":"Exceptions","text":"type_error.310 if called on JSON values other than arrays; example: \"cannot use swap(array_t&) with boolean\"type_error.310 if called on JSON values other than objects; example: \"cannot use swap(object_t&) with boolean\"type_error.310 if called on JSON values other than strings; example: \"cannot use swap(string_t&) with boolean\"type_error.310 if called on JSON values other than binaries; example: \"cannot use swap(binary_t&) with boolean\"type_error.310 if called on JSON values other than binaries; example: \"cannot use swap(binary_t::container_type&) with boolean\"Constant.
"},{"location":"api/basic_json/swap/#examples","title":"Examples","text":"Example: Swap JSON value (1, 2)The example below shows how JSON values can be swapped with swap().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create two JSON values\n json j1 = {1, 2, 3, 4, 5};\n json j2 = {{\"pi\", 3.141592653589793}, {\"e\", 2.718281828459045}};\n\n // swap the values\n j1.swap(j2);\n\n // output the values\n std::cout << \"j1 = \" << j1 << '\\n';\n std::cout << \"j2 = \" << j2 << '\\n';\n}\nOutput:
j1 = {\"e\":2.718281828459045,\"pi\":3.141592653589793}\nj2 = [1,2,3,4,5]\nThe example below shows how arrays can be swapped with swap().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value\n json value = {{\"array\", {1, 2, 3, 4}}};\n\n // create an array_t\n json::array_t array = {\"Snap\", \"Crackle\", \"Pop\"};\n\n // swap the array stored in the JSON value\n value[\"array\"].swap(array);\n\n // output the values\n std::cout << \"value = \" << value << '\\n';\n std::cout << \"array = \" << array << '\\n';\n}\nOutput:
value = {\"array\":[\"Snap\",\"Crackle\",\"Pop\"]}\narray = [1,2,3,4]\nThe example below shows how objects can be swapped with swap().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value\n json value = { {\"translation\", {{\"one\", \"eins\"}, {\"two\", \"zwei\"}}} };\n\n // create an object_t\n json::object_t object = {{\"cow\", \"Kuh\"}, {\"dog\", \"Hund\"}};\n\n // swap the object stored in the JSON value\n value[\"translation\"].swap(object);\n\n // output the values\n std::cout << \"value = \" << value << '\\n';\n std::cout << \"object = \" << object << '\\n';\n}\nOutput:
value = {\"translation\":{\"cow\":\"Kuh\",\"dog\":\"Hund\"}}\nobject = {\"one\":\"eins\",\"two\":\"zwei\"}\nThe example below shows how strings can be swapped with swap().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value\n json value = { \"the good\", \"the bad\", \"the ugly\" };\n\n // create string_t\n json::string_t string = \"the fast\";\n\n // swap the object stored in the JSON value\n value[1].swap(string);\n\n // output the values\n std::cout << \"value = \" << value << '\\n';\n std::cout << \"string = \" << string << '\\n';\n}\nOutput:
value = [\"the good\",\"the fast\",\"the ugly\"]\nstring = the bad\nThe example below shows how binary values can be swapped with swap().
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a binary value\n json value = json::binary({1, 2, 3});\n\n // create a binary_t\n json::binary_t binary = {{4, 5, 6}};\n\n // swap the object stored in the JSON value\n value.swap(binary);\n\n // output the values\n std::cout << \"value = \" << value << '\\n';\n std::cout << \"binary = \" << json(binary) << '\\n';\n}\nOutput:
value = {\"bytes\":[4,5,6],\"subtype\":null}\nbinary = {\"bytes\":[1,2,3],\"subtype\":null}\n// (1)\nstatic std::vector<std::uint8_t> to_bjdata(const basic_json& j,\n const bool use_size = false,\n const bool use_type = false,\n const bjdata_version_t version = bjdata_version_t::draft2);\n\n// (2)\nstatic void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,\n const bool use_size = false, const bool use_type = false,\n const bjdata_version_t version = bjdata_version_t::draft2);\nstatic void to_bjdata(const basic_json& j, detail::output_adapter<char> o,\n const bool use_size = false, const bool use_type = false,\n const bjdata_version_t version = bjdata_version_t::draft2);\nSerializes a given JSON value j to a byte vector using the BJData (Binary JData) serialization format. BJData aims to be more compact than JSON itself, yet more efficient to parse.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/to_bjdata/#parameters","title":"Parameters","text":"j (in) JSON value to serialize o (in) output adapter to write serialization to use_size (in) whether to add size annotations to container types; optional, false by default. use_type (in) whether to add type annotations to container types (must be combined with use_size = true); optional, false by default. version (in) which version of BJData to use (see note on \"Binary values\" on BJData); optional, bjdata_version_t::draft2 by default."},{"location":"api/basic_json/to_bjdata/#return-value","title":"Return value","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/to_bjdata/#complexity","title":"Complexity","text":"Linear in the size of the JSON value j.
The example shows the serialization of a JSON value to a byte vector in BJData format.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\n// function to print BJData's diagnostic format\nvoid print_byte(uint8_t byte)\n{\n if (32 < byte and byte < 128)\n {\n std::cout << (char)byte;\n }\n else\n {\n std::cout << (int)byte;\n }\n}\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": false})\"_json;\n\n // serialize it to BJData\n std::vector<std::uint8_t> v = json::to_bjdata(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n // create an array of numbers\n json array = {1, 2, 3, 4, 5, 6, 7, 8};\n\n // serialize it to BJData using default representation\n std::vector<std::uint8_t> v_array = json::to_bjdata(array);\n // serialize it to BJData using size optimization\n std::vector<std::uint8_t> v_array_size = json::to_bjdata(array, true);\n // serialize it to BJData using type optimization\n std::vector<std::uint8_t> v_array_size_and_type = json::to_bjdata(array, true, true);\n\n // print the vector contents\n for (auto& byte : v_array)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n for (auto& byte : v_array_size)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n for (auto& byte : v_array_size_and_type)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n}\nOutput:
{i7compactTi6schemaF}\n[i1i2i3i4i5i6i7i8]\n[#i8i1i2i3i4i5i6i7i8\n[$i#i812345678\n// (1)\nstatic std::vector<std::uint8_t> to_bson(const basic_json& j);\n\n// (2)\nstatic void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o);\nstatic void to_bson(const basic_json& j, detail::output_adapter<char> o);\nBSON (Binary JSON) is a binary format in which zero or more ordered key/value pairs are stored as a single entity (a so-called document).
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/to_bson/#parameters","title":"Parameters","text":"j (in) JSON value to serialize o (in) output adapter to write serialization to"},{"location":"api/basic_json/to_bson/#return-value","title":"Return value","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/to_bson/#exceptions","title":"Exceptions","text":"type_error.317 if the top-level type of the JSON value is not an object; example: \"to serialize to BSON, top-level type must be object, but is string\"out_of_range.409 if a key in the JSON object contains a null byte (code point U+0000); example: \"BSON key cannot contain code point U+0000 (at byte 2)\"Linear in the size of the JSON value j.
The example shows the serialization of a JSON value to a byte vector in BSON format.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": 0})\"_json;\n\n // serialize it to BSON\n std::vector<std::uint8_t> v = json::to_bson(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n std::cout << \"0x\" << std::hex << std::setw(2) << std::setfill('0') << (int)byte << \" \";\n }\n std::cout << std::endl;\n}\nOutput:
0x1b 0x00 0x00 0x00 0x08 0x63 0x6f 0x6d 0x70 0x61 0x63 0x74 0x00 0x01 0x10 0x73 0x63 0x68 0x65 0x6d 0x61 0x00 0x00 0x00 0x00 0x00 0x00 \n// (1)\nstatic std::vector<std::uint8_t> to_cbor(const basic_json& j);\n\n// (2)\nstatic void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o);\nstatic void to_cbor(const basic_json& j, detail::output_adapter<char> o);\nSerializes a given JSON value j to a byte vector using the CBOR (Concise Binary Object Representation) serialization format. CBOR is a binary serialization format that aims to be more compact than JSON itself, yet more efficient to parse.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/to_cbor/#parameters","title":"Parameters","text":"j (in) JSON value to serialize o (in) output adapter to write serialization to"},{"location":"api/basic_json/to_cbor/#return-value","title":"Return value","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/to_cbor/#complexity","title":"Complexity","text":"Linear in the size of the JSON value j.
The example shows the serialization of a JSON value to a byte vector in CBOR format.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": 0})\"_json;\n\n // serialize it to CBOR\n std::vector<std::uint8_t> v = json::to_cbor(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n std::cout << \"0x\" << std::hex << std::setw(2) << std::setfill('0') << (int)byte << \" \";\n }\n std::cout << std::endl;\n}\nOutput:
0xa2 0x67 0x63 0x6f 0x6d 0x70 0x61 0x63 0x74 0xf5 0x66 0x73 0x63 0x68 0x65 0x6d 0x61 0x00 \n// (1)\nstatic std::vector<std::uint8_t> to_msgpack(const basic_json& j);\n\n// (2)\nstatic void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o);\nstatic void to_msgpack(const basic_json& j, detail::output_adapter<char> o);\nSerializes a given JSON value j to a byte vector using the MessagePack serialization format. MessagePack is a binary serialization format that aims to be more compact than JSON itself, yet more efficient to parse.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/to_msgpack/#parameters","title":"Parameters","text":"j (in) JSON value to serialize o (in) output adapter to write serialization to"},{"location":"api/basic_json/to_msgpack/#return-value","title":"Return value","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/to_msgpack/#complexity","title":"Complexity","text":"Linear in the size of the JSON value j.
The example shows the serialization of a JSON value to a byte vector in MessagePack format.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": 0})\"_json;\n\n // serialize it to MessagePack\n std::vector<std::uint8_t> v = json::to_msgpack(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n std::cout << \"0x\" << std::hex << std::setw(2) << std::setfill('0') << (int)byte << \" \";\n }\n std::cout << std::endl;\n}\nOutput:
0x82 0xa7 0x63 0x6f 0x6d 0x70 0x61 0x63 0x74 0xc3 0xa6 0x73 0x63 0x68 0x65 0x6d 0x61 0x00 \ntemplate <typename BasicJsonType>\nstd::string to_string(const BasicJsonType& j);\nThis function implements a user-defined to_string for JSON objects.
"},{"location":"api/basic_json/to_string/#template-parameters","title":"Template parameters","text":"BasicJsonType a specialization of basic_json"},{"location":"api/basic_json/to_string/#return-value","title":"Return value","text":"string containing the serialization of the JSON value
"},{"location":"api/basic_json/to_string/#exception-safety","title":"Exception safety","text":"Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
"},{"location":"api/basic_json/to_string/#exceptions","title":"Exceptions","text":"Throws type_error.316 if a string stored inside the JSON value is not UTF-8 encoded
Linear.
"},{"location":"api/basic_json/to_string/#possible-implementation","title":"Possible implementation","text":"template <typename BasicJsonType>\nstd::string to_string(const BasicJsonType& j)\n{\n return j.dump();\n}\nThe following code shows how the library's to_string() function integrates with others, allowing argument-dependent lookup.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing std::to_string;\n\nint main()\n{\n // create values\n json j = {{\"one\", 1}, {\"two\", 2}};\n int i = 42;\n\n // use ADL to select best to_string function\n auto j_str = to_string(j); // calling nlohmann::to_string\n auto i_str = to_string(i); // calling std::to_string\n\n // serialize without indentation\n std::cout << j_str << \"\\n\\n\"\n << i_str << std::endl;\n}\nOutput:
{\"one\":1,\"two\":2}\n\n42\nAdded in version 3.7.0.
"},{"location":"api/basic_json/to_ubjson/","title":"nlohmann::basic_json::to_ubjson","text":"// (1)\nstatic std::vector<std::uint8_t> to_ubjson(const basic_json& j,\n const bool use_size = false,\n const bool use_type = false);\n\n// (2)\nstatic void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,\n const bool use_size = false, const bool use_type = false);\nstatic void to_ubjson(const basic_json& j, detail::output_adapter<char> o,\n const bool use_size = false, const bool use_type = false);\nSerializes a given JSON value j to a byte vector using the UBJSON (Universal Binary JSON) serialization format. UBJSON aims to be more compact than JSON itself, yet more efficient to parse.
The exact mapping and its limitations are described on a dedicated page.
"},{"location":"api/basic_json/to_ubjson/#parameters","title":"Parameters","text":"j (in) JSON value to serialize o (in) output adapter to write serialization to use_size (in) whether to add size annotations to container types; optional, false by default. use_type (in) whether to add type annotations to container types (must be combined with use_size = true); optional, false by default."},{"location":"api/basic_json/to_ubjson/#return-value","title":"Return value","text":"Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
"},{"location":"api/basic_json/to_ubjson/#complexity","title":"Complexity","text":"Linear in the size of the JSON value j.
The example shows the serialization of a JSON value to a byte vector in UBJSON format.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\n// function to print UBJSON's diagnostic format\nvoid print_byte(uint8_t byte)\n{\n if (32 < byte and byte < 128)\n {\n std::cout << (char)byte;\n }\n else\n {\n std::cout << (int)byte;\n }\n}\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": false})\"_json;\n\n // serialize it to UBJSON\n std::vector<std::uint8_t> v = json::to_ubjson(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n // create an array of numbers\n json array = {1, 2, 3, 4, 5, 6, 7, 8};\n\n // serialize it to UBJSON using default representation\n std::vector<std::uint8_t> v_array = json::to_ubjson(array);\n // serialize it to UBJSON using size optimization\n std::vector<std::uint8_t> v_array_size = json::to_ubjson(array, true);\n // serialize it to UBJSON using type optimization\n std::vector<std::uint8_t> v_array_size_and_type = json::to_ubjson(array, true, true);\n\n // print the vector contents\n for (auto& byte : v_array)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n for (auto& byte : v_array_size)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n for (auto& byte : v_array_size_and_type)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n}\nOutput:
{i7compactTi6schemaF}\n[i1i2i3i4i5i6i7i8]\n[#i8i1i2i3i4i5i6i7i8\n[$i#i812345678\nconstexpr value_t type() const noexcept;\nReturn the type of the JSON value as a value from the value_t enumeration.
the type of the JSON value
Value type return valuenull value_t::null boolean value_t::boolean string value_t::string number (integer) value_t::number_integer number (unsigned integer) value_t::number_unsigned number (floating-point) value_t::number_float object value_t::object array value_t::array binary value_t::binary discarded value_t::discarded"},{"location":"api/basic_json/type/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/type/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/type/#examples","title":"Examples","text":"ExampleThe following code exemplifies type() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = -17;\n json j_number_unsigned = 42u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n\n // call type()\n std::cout << std::boolalpha;\n std::cout << (j_null.type() == json::value_t::null) << '\\n';\n std::cout << (j_boolean.type() == json::value_t::boolean) << '\\n';\n std::cout << (j_number_integer.type() == json::value_t::number_integer) << '\\n';\n std::cout << (j_number_unsigned.type() == json::value_t::number_unsigned) << '\\n';\n std::cout << (j_number_float.type() == json::value_t::number_float) << '\\n';\n std::cout << (j_object.type() == json::value_t::object) << '\\n';\n std::cout << (j_array.type() == json::value_t::array) << '\\n';\n std::cout << (j_string.type() == json::value_t::string) << '\\n';\n}\nOutput:
true\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\nclass type_error : public exception;\nThis exception is thrown in case of a type error; that is, a library function is executed on a JSON value whose type does not match the expected semantics.
Exceptions have ids 3xx (see list of type errors).
classDiagram\n direction LR\n\n class std_exception [\"std::exception\"] {\n <<interface>>\n }\n\n class json_exception [\"basic_json::exception\"] {\n +const int id\n +const char* what() const\n }\n\n class json_parse_error [\"basic_json::parse_error\"] {\n +const std::size_t byte\n }\n\n class json_invalid_iterator [\"basic_json::invalid_iterator\"]\n class json_type_error [\"basic_json::type_error\"]\n class json_out_of_range [\"basic_json::out_of_range\"]\n class json_other_error [\"basic_json::other_error\"]\n\n std_exception <|-- json_exception\n json_exception <|-- json_parse_error\n json_exception <|-- json_invalid_iterator\n json_exception <|-- json_type_error\n json_exception <|-- json_out_of_range\n json_exception <|-- json_other_error\n\n style json_type_error fill:#CCCCFFThe following code shows how a type_error exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // calling push_back() on a string value\n json j = \"string\";\n j.push_back(\"another string\");\n }\n catch (const json::type_error& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.type_error.308] cannot use push_back() with string\nexception id: 308\nexception for the base class of all exceptions thrown by the libraryparse_error for exceptions indicating a parse errorinvalid_iterator for exceptions indicating errors with iteratorsout_of_range for exceptions indicating access out of the defined rangeother_error for exceptions indicating other library errorsconst char* type_name() const noexcept;\nReturns the type name as string to be used in error messages -- usually to indicate that a function was called on a wrong JSON type.
"},{"location":"api/basic_json/type_name/#return-value","title":"Return value","text":"a string representation of the type (value_t):
null \"null\" boolean \"boolean\" string \"string\" number (integer, unsigned integer, floating-point) \"number\" object \"object\" array \"array\" binary \"binary\" discarded \"discarded\""},{"location":"api/basic_json/type_name/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/type_name/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/basic_json/type_name/#examples","title":"Examples","text":"ExampleThe following code exemplifies type_name() for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = -17;\n json j_number_unsigned = 42u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n\n // call type_name()\n std::cout << j_null << \" is a \" << j_null.type_name() << '\\n';\n std::cout << j_boolean << \" is a \" << j_boolean.type_name() << '\\n';\n std::cout << j_number_integer << \" is a \" << j_number_integer.type_name() << '\\n';\n std::cout << j_number_unsigned << \" is a \" << j_number_unsigned.type_name() << '\\n';\n std::cout << j_number_float << \" is a \" << j_number_float.type_name() << '\\n';\n std::cout << j_object << \" is an \" << j_object.type_name() << '\\n';\n std::cout << j_array << \" is an \" << j_array.type_name() << '\\n';\n std::cout << j_string << \" is a \" << j_string.type_name() << '\\n';\n}\nOutput:
null is a null\ntrue is a boolean\n-17 is a number\n42 is a number\n23.42 is a number\n{\"one\":1,\"two\":2} is an object\n[1,2,4,8,16] is an array\n\"Hello, world\" is a string\nconst char* and added noexcept in version 3.0.0.basic_json unflatten() const;\nThe function restores the arbitrary nesting of a JSON value that has been flattened before using the flatten() function. The JSON value must meet certain constraints:
the original JSON from a flattened version
"},{"location":"api/basic_json/unflatten/#exception-safety","title":"Exception safety","text":"Strong exception safety: if an exception occurs, the original value stays intact.
"},{"location":"api/basic_json/unflatten/#exceptions","title":"Exceptions","text":"The function can throw the following exceptions:
type_error.314 if value is not an objecttype_error.315 if object values are not primitivetype_error.313 if a key (JSON pointer) leads to a conflicting nesting; example: \"invalid value to unflatten\"parse_error.109 if an array index in a key is not a number; example: \"array index 'one' is not a number\"Linear in the size of the JSON value.
"},{"location":"api/basic_json/unflatten/#notes","title":"Notes","text":"Empty objects and arrays are flattened by flatten() to null values and cannot unflattened to their original type. Apart from this example, for a JSON value j, the following is always true: j == j.flatten().unflatten().
The following code shows how a flattened JSON object is unflattened into the original nested JSON object.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON value\n json j_flattened =\n {\n {\"/answer/everything\", 42},\n {\"/happy\", true},\n {\"/list/0\", 1},\n {\"/list/1\", 0},\n {\"/list/2\", 2},\n {\"/name\", \"Niels\"},\n {\"/nothing\", nullptr},\n {\"/object/currency\", \"USD\"},\n {\"/object/value\", 42.99},\n {\"/pi\", 3.141}\n };\n\n // call unflatten()\n std::cout << std::setw(4) << j_flattened.unflatten() << '\\n';\n}\nOutput:
{\n \"answer\": {\n \"everything\": 42\n },\n \"happy\": true,\n \"list\": [\n 1,\n 0,\n 2\n ],\n \"name\": \"Niels\",\n \"nothing\": null,\n \"object\": {\n \"currency\": \"USD\",\n \"value\": 42.99\n },\n \"pi\": 3.141\n}\n// (1)\nvoid update(const_reference j, bool merge_objects = false);\n\n// (2)\nvoid update(const_iterator first, const_iterator last, bool merge_objects = false);\nj.[first, last)When merge_objects is false (default), existing keys are overwritten. When merge_objects is true, recursively merges objects with common keys.
If the JSON value is null, it is implicitly converted to an empty object before the values are inserted.
The function is motivated by Python's dict.update function.
"},{"location":"api/basic_json/update/#iterator-invalidation","title":"Iterator invalidation","text":"For ordered_json, adding a value to an object can yield a reallocation, in which case all iterators (including the end() iterator) and all references to the elements are invalidated.
j (in) JSON object to read values from merge_objects (in) when true, keys that exist in both objects and whose value in the source is itself an object are merged recursively; all other values are overwritten as usual (default: false) first (in) the beginning of the range of elements to insert last (in) the end of the range of elements to insert"},{"location":"api/basic_json/update/#exception-safety","title":"Exception safety","text":"Basic guarantee: if an exception is thrown during the operation, the JSON value may be partially modified.
"},{"location":"api/basic_json/update/#exceptions","title":"Exceptions","text":"type_error.312 if called on JSON values other than objects; example: \"cannot use update() with string\"type_error.312 if called on JSON values other than objects; example: \"cannot use update() with string\"invalid_iterator.210 if first and last do not belong to the same JSON value; example: \"iterators do not fit\"The example shows how update() is used.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create two JSON objects\n json o1 = R\"( {\"color\": \"red\", \"price\": 17.99, \"names\": {\"de\": \"Flugzeug\"}} )\"_json;\n json o2 = R\"( {\"color\": \"blue\", \"speed\": 100, \"names\": {\"en\": \"plane\"}} )\"_json;\n json o3 = o1;\n\n // add all keys from o2 to o1 (updating \"color\", replacing \"names\")\n o1.update(o2);\n\n // add all keys from o2 to o1 (updating \"color\", merging \"names\")\n o3.update(o2, true);\n\n // output updated object o1 and o3\n std::cout << std::setw(2) << o1 << '\\n';\n std::cout << std::setw(2) << o3 << '\\n';\n}\nOutput:
{\n \"color\": \"blue\",\n \"names\": {\n \"en\": \"plane\"\n },\n \"price\": 17.99,\n \"speed\": 100\n}\n{\n \"color\": \"blue\",\n \"names\": {\n \"de\": \"Flugzeug\",\n \"en\": \"plane\"\n },\n \"price\": 17.99,\n \"speed\": 100\n}\nThe example shows how update() is used.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create two JSON objects\n json o1 = R\"( {\"color\": \"red\", \"price\": 17.99, \"names\": {\"de\": \"Flugzeug\"}} )\"_json;\n json o2 = R\"( {\"color\": \"blue\", \"speed\": 100, \"names\": {\"en\": \"plane\"}} )\"_json;\n json o3 = o1;\n\n // add all keys from o2 to o1 (updating \"color\", replacing \"names\")\n o1.update(o2.begin(), o2.end());\n\n // add all keys from o2 to o1 (updating \"color\", merging \"names\")\n o3.update(o2.begin(), o2.end(), true);\n\n // output updated object o1 and o3\n std::cout << std::setw(2) << o1 << '\\n';\n std::cout << std::setw(2) << o3 << '\\n';\n}\nOutput:
{\n \"color\": \"blue\",\n \"names\": {\n \"en\": \"plane\"\n },\n \"price\": 17.99,\n \"speed\": 100\n}\n{\n \"color\": \"blue\",\n \"names\": {\n \"de\": \"Flugzeug\",\n \"en\": \"plane\"\n },\n \"price\": 17.99,\n \"speed\": 100\n}\nOne common use case for this function is the handling of user settings. Assume your application can be configured in some aspects:
{\n \"color\": \"red\",\n \"active\": true,\n \"name\": {\"de\": \"Maus\", \"en\": \"mouse\"}\n}\nThe user may override the default settings selectively:
{\n \"color\": \"blue\",\n \"name\": {\"es\": \"rat\u00f3n\"},\n}\nThen update manages the merging of default settings and user settings:
auto user_settings = json::parse(\"config.json\");\nauto effective_settings = get_default_settings();\neffective_settings.update(user_settings);\nNow effective_settings contains the default settings, but those keys set by the user are overwritten:
{\n \"color\": \"blue\",\n \"active\": true,\n \"name\": {\"es\": \"rat\u00f3n\"}\n}\nNote existing keys were just overwritten. To merge objects, merge_objects setting should be set to true:
auto user_settings = json::parse(\"config.json\");\nauto effective_settings = get_default_settings();\neffective_settings.update(user_settings, true);\n{\n \"color\": \"blue\",\n \"active\": true,\n \"name\": {\"de\": \"Maus\", \"en\": \"mouse\", \"es\": \"rat\u00f3n\"}\n}\nmerge_objects parameter in 3.10.5.// (1)\ntemplate<class ValueType>\nValueType value(const typename object_t::key_type& key,\n ValueType&& default_value) const;\n\n// (2)\ntemplate<class ValueType, class KeyType>\nValueType value(KeyType&& key,\n ValueType&& default_value) const;\n\n// (3)\ntemplate<class ValueType>\nValueType value(const json_pointer& ptr,\n const ValueType& default_value) const;\nReturns either a copy of an object's element at the specified key key or a given default value if no element with key key exists.
The function is basically equivalent to executing
try {\n return at(key);\n} catch(out_of_range) {\n return default_value;\n}\nSee 1. This overload is only available if KeyType is comparable with typename object_t::key_type and typename object_comparator_t::is_transparent denotes a type.
Returns either a copy of an object's element at the specified JSON pointer ptr or a given default value if no value at ptr exists.
The function is basically equivalent to executing
try {\n return at(ptr);\n} catch(out_of_range) {\n return default_value;\n}\nDifferences to at and operator[]
at, this function does not throw if the given key/ptr was not found.operator[], this function does not implicitly add an element to the position defined by key/ptr key. This function is furthermore also applicable to const objects.KeyType A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17). ValueType type compatible to JSON values, for instance int for JSON integer numbers, bool for JSON booleans, or std::vector types for JSON arrays. Note the type of the expected value at key/ptr and the default value default_value must be compatible."},{"location":"api/basic_json/value/#parameters","title":"Parameters","text":"key (in) key of the element to access default_value (in) the value to return if key/ptr found no value ptr (in) a JSON pointer to the element to access"},{"location":"api/basic_json/value/#return-value","title":"Return value","text":"key or default_value if key is not foundkey or default_value if key is not foundptr or default_value if no value for ptr is foundStrong guarantee: if an exception is thrown, there are no changes to any JSON value.
"},{"location":"api/basic_json/value/#exceptions","title":"Exceptions","text":"type_error.302 if default_value does not match the type of the value at keytype_error.306 if the JSON value is not an object; in that case, using value() with a key makes no sense.type_error.302 if default_value does not match the type of the value at ptrtype_error.306 if the JSON value is not an array or object; in that case, using value() with a JSON pointer makes no sense.parse_error.106 if an array index in the passed JSON pointer ptr begins with '0'.parse_error.109 if an array index in the passed JSON pointer ptr is not a number.Return type
The value function is a template, and the return type of the function is determined by the type of the provided default value unless otherwise specified. This can have unexpected effects. In the example below, we store a 64-bit unsigned integer. We get exactly that value when using operator[]. However, when we call value and provide 0 as default value, then -1 is returned. This occurs, because 0 has type int which overflows when handling the value 18446744073709551615.
To address this issue, either provide a correctly typed default value or use the template parameter to specify the desired return type. Note that this issue occurs even when a value is stored at the provided key, and the default value is not used as the return value.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j = json::parse(R\"({\"uint64\": 18446744073709551615})\");\n\n std::cout << \"operator[]: \" << j[\"uint64\"] << '\\n'\n << \"default value (int): \" << j.value(\"uint64\", 0) << '\\n'\n << \"default value (uint64_t): \" << j.value(\"uint64\", std::uint64_t(0)) << '\\n'\n << \"explicit return value type: \" << j.value<std::uint64_t>(\"uint64\", 0) << '\\n';\n}\nOutput:
operator[]: 18446744073709551615\ndefault value (int): -1\ndefault value (uint64_t): 18446744073709551615\nexplicit return value type: 18446744073709551615\nThe example below shows how object elements can be queried with a default value.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object with different entry types\n json j =\n {\n {\"integer\", 1},\n {\"floating\", 42.23},\n {\"string\", \"hello world\"},\n {\"boolean\", true},\n {\"object\", {{\"key1\", 1}, {\"key2\", 2}}},\n {\"array\", {1, 2, 3}}\n };\n\n // access existing values\n int v_integer = j.value(\"integer\", 0);\n double v_floating = j.value(\"floating\", 47.11);\n\n // access nonexisting values and rely on default value\n std::string v_string = j.value(\"nonexisting\", \"oops\");\n bool v_boolean = j.value(\"nonexisting\", false);\n\n // output values\n std::cout << std::boolalpha << v_integer << \" \" << v_floating\n << \" \" << v_string << \" \" << v_boolean << \"\\n\";\n}\nOutput:
1 42.23 oops false\nThe example below shows how object elements can be queried with a default value.
#include <iostream>\n#include <string_view>\n#include <nlohmann/json.hpp>\n\nusing namespace std::string_view_literals;\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON object with different entry types\n json j =\n {\n {\"integer\", 1},\n {\"floating\", 42.23},\n {\"string\", \"hello world\"},\n {\"boolean\", true},\n {\"object\", {{\"key1\", 1}, {\"key2\", 2}}},\n {\"array\", {1, 2, 3}}\n };\n\n // access existing values\n int v_integer = j.value(\"integer\"sv, 0);\n double v_floating = j.value(\"floating\"sv, 47.11);\n\n // access nonexisting values and rely on default value\n std::string v_string = j.value(\"nonexisting\"sv, \"oops\");\n bool v_boolean = j.value(\"nonexisting\"sv, false);\n\n // output values\n std::cout << std::boolalpha << v_integer << \" \" << v_floating\n << \" \" << v_string << \" \" << v_boolean << \"\\n\";\n}\nOutput:
1 42.23 oops false\nThe example below shows how object elements can be queried with a default value.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON object with different entry types\n json j =\n {\n {\"integer\", 1},\n {\"floating\", 42.23},\n {\"string\", \"hello world\"},\n {\"boolean\", true},\n {\"object\", {{\"key1\", 1}, {\"key2\", 2}}},\n {\"array\", {1, 2, 3}}\n };\n\n // access existing values\n int v_integer = j.value(\"/integer\"_json_pointer, 0);\n double v_floating = j.value(\"/floating\"_json_pointer, 47.11);\n\n // access nonexisting values and rely on default value\n std::string v_string = j.value(\"/nonexisting\"_json_pointer, \"oops\");\n bool v_boolean = j.value(\"/nonexisting\"_json_pointer, false);\n\n // output values\n std::cout << std::boolalpha << v_integer << \" \" << v_floating\n << \" \" << v_string << \" \" << v_boolean << \"\\n\";\n}\nOutput:
1 42.23 oops false\nat for access by reference with range checkingoperator[] for unchecked access by referencedefault_value type from const ValueType& to ValueType&& in version 3.11.0.ValueType the first template parameter in version 3.11.2.enum class value_t : std::uint8_t {\n null,\n object,\n array,\n string,\n boolean,\n number_integer,\n number_unsigned,\n number_float,\n binary,\n discarded\n};\nThis enumeration collects the different JSON types. It is internally used to distinguish the stored values, and the functions is_null, is_object, is_array, is_string, is_boolean, is_number (with is_number_integer, is_number_unsigned, and is_number_float), is_discarded, is_binary, is_primitive, and is_structured rely on it.
Ordering
The order of types is as follows:
nullbooleannumber_integer, number_unsigned, number_floatobjectarraystringbinarydiscarded is unordered.
Types of numbers
There are three enumerators for numbers (number_integer, number_unsigned, and number_float) to distinguish between different types of numbers:
number_unsigned_t for unsigned integersnumber_integer_t for signed integersnumber_float_t for floating-point numbers or to approximate integers which do not fit into the limits of their respective typeComparison operators
operator< and operator<=> (since C++20) are overloaded and compare according to the ordering described above. Until C++20 all other relational and equality operators yield results according to the integer value of each enumerator. Since C++20 some compilers consider the rewritten candidates generated from operator<=> during overload resolution, while others do not. For predictable and portable behavior use:
operator< or operator<=> when wanting to compare according to the order described aboveoperator== or operator!= when wanting to compare according to each enumerators integer valueThe following code how type() queries the value_t for all JSON types.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_null;\n json j_boolean = true;\n json j_number_integer = -17;\n json j_number_unsigned = 42u;\n json j_number_float = 23.42;\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hello, world\";\n\n // call type()\n std::cout << std::boolalpha;\n std::cout << (j_null.type() == json::value_t::null) << '\\n';\n std::cout << (j_boolean.type() == json::value_t::boolean) << '\\n';\n std::cout << (j_number_integer.type() == json::value_t::number_integer) << '\\n';\n std::cout << (j_number_unsigned.type() == json::value_t::number_unsigned) << '\\n';\n std::cout << (j_number_float.type() == json::value_t::number_float) << '\\n';\n std::cout << (j_object.type() == json::value_t::object) << '\\n';\n std::cout << (j_array.type() == json::value_t::array) << '\\n';\n std::cout << (j_string.type() == json::value_t::string) << '\\n';\n}\nOutput:
true\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\n~basic_json() noexcept;\nDestroys the JSON value and frees all allocated memory.
"},{"location":"api/basic_json/~basic_json/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this member function never throws exceptions.
"},{"location":"api/basic_json/~basic_json/#complexity","title":"Complexity","text":"Linear.
"},{"location":"api/basic_json/~basic_json/#version-history","title":"Version history","text":"template<typename BinaryType>\nclass byte_container_with_subtype : public BinaryType;\nThis type extends the template parameter BinaryType provided to basic_json with a subtype used by BSON and MessagePack. This type exists so that the user does not have to specify a type themselves with a specific naming scheme in order to override the binary type.
BinaryType container to store bytes (std::vector<std::uint8_t> by default)"},{"location":"api/byte_container_with_subtype/#member-types","title":"Member types","text":"BinaryType)std::uint64_t)std::uint64_t in 3.10.0.// (1)\nbyte_container_with_subtype();\n\n// (2)\nbyte_container_with_subtype(const container_type& container);\nbyte_container_with_subtype(container_type&& container);\n\n// (3)\nbyte_container_with_subtype(const container_type& container, subtype_type subtype);\nbyte_container_with_subtype(container_type&& container, subtype_type subtype);\ncontainer (in) binary container subtype (in) subtype"},{"location":"api/byte_container_with_subtype/byte_container_with_subtype/#examples","title":"Examples","text":"Example The example below demonstrates how byte containers can be created.
#include <iostream>\n#include <nlohmann/json.hpp>\n\n// define a byte container based on std::vector\nusing byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;\n\nusing json = nlohmann::json;\n\nint main()\n{\n // (1) create empty container\n auto c1 = byte_container_with_subtype();\n\n std::vector<std::uint8_t> bytes = {{0xca, 0xfe, 0xba, 0xbe}};\n\n // (2) create container\n auto c2 = byte_container_with_subtype(bytes);\n\n // (3) create container with subtype\n auto c3 = byte_container_with_subtype(bytes, 42);\n\n std::cout << json(c1) << \"\\n\" << json(c2) << \"\\n\" << json(c3) << std::endl;\n}\nOutput:
{\"bytes\":[],\"subtype\":null}\n{\"bytes\":[202,254,186,190],\"subtype\":null}\n{\"bytes\":[202,254,186,190],\"subtype\":42}\nSince version 3.8.0.
"},{"location":"api/byte_container_with_subtype/clear_subtype/","title":"nlohmann::byte_container_with_subtype::clear_subtype","text":"void clear_subtype() noexcept;\nClears the binary subtype and flags the value as not having a subtype, which has implications for serialization; for instance, MessagePack will prefer the bin family over the ext family.
"},{"location":"api/byte_container_with_subtype/clear_subtype/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this function never throws exceptions.
"},{"location":"api/byte_container_with_subtype/clear_subtype/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/byte_container_with_subtype/clear_subtype/#examples","title":"Examples","text":"ExampleThe example below demonstrates how clear_subtype can remove subtypes.
#include <iostream>\n#include <nlohmann/json.hpp>\n\n// define a byte container based on std::vector\nusing byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::vector<std::uint8_t> bytes = {{0xca, 0xfe, 0xba, 0xbe}};\n\n // create container with subtype\n auto c1 = byte_container_with_subtype(bytes, 42);\n\n std::cout << \"before calling clear_subtype(): \" << json(c1) << '\\n';\n\n c1.clear_subtype();\n\n std::cout << \"after calling clear_subtype(): \" << json(c1) << '\\n';\n}\nOutput:
before calling clear_subtype(): {\"bytes\":[202,254,186,190],\"subtype\":42}\nafter calling clear_subtype(): {\"bytes\":[202,254,186,190],\"subtype\":null}\nSince version 3.8.0.
"},{"location":"api/byte_container_with_subtype/has_subtype/","title":"nlohmann::byte_container_with_subtype::has_subtype","text":"constexpr bool has_subtype() const noexcept;\nReturns whether the value has a subtype.
"},{"location":"api/byte_container_with_subtype/has_subtype/#return-value","title":"Return value","text":"whether the value has a subtype
"},{"location":"api/byte_container_with_subtype/has_subtype/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this function never throws exceptions.
"},{"location":"api/byte_container_with_subtype/has_subtype/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/byte_container_with_subtype/has_subtype/#examples","title":"Examples","text":"ExampleThe example below demonstrates how has_subtype can check whether a subtype was set.
#include <iostream>\n#include <nlohmann/json.hpp>\n\n// define a byte container based on std::vector\nusing byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;\n\nint main()\n{\n std::vector<std::uint8_t> bytes = {{0xca, 0xfe, 0xba, 0xbe}};\n\n // create container\n auto c1 = byte_container_with_subtype(bytes);\n\n // create container with subtype\n auto c2 = byte_container_with_subtype(bytes, 42);\n\n std::cout << std::boolalpha << \"c1.has_subtype() = \" << c1.has_subtype()\n << \"\\nc2.has_subtype() = \" << c2.has_subtype() << std::endl;\n}\nOutput:
c1.has_subtype() = false\nc2.has_subtype() = true\nSince version 3.8.0.
"},{"location":"api/byte_container_with_subtype/set_subtype/","title":"nlohmann::byte_container_with_subtype::set_subtype","text":"void set_subtype(subtype_type subtype) noexcept;\nSets the binary subtype of the value, also flags a binary JSON value as having a subtype, which has implications for serialization.
"},{"location":"api/byte_container_with_subtype/set_subtype/#parameters","title":"Parameters","text":"subtype (in) subtype to set"},{"location":"api/byte_container_with_subtype/set_subtype/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this function never throws exceptions.
"},{"location":"api/byte_container_with_subtype/set_subtype/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/byte_container_with_subtype/set_subtype/#examples","title":"Examples","text":"ExampleThe example below demonstrates how a subtype can be set with set_subtype.
#include <iostream>\n#include <nlohmann/json.hpp>\n\n// define a byte container based on std::vector\nusing byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::vector<std::uint8_t> bytes = {{0xca, 0xfe, 0xba, 0xbe}};\n\n // create container without subtype\n auto c = byte_container_with_subtype(bytes);\n\n std::cout << \"before calling set_subtype(42): \" << json(c) << '\\n';\n\n // set the subtype\n c.set_subtype(42);\n\n std::cout << \"after calling set_subtype(42): \" << json(c) << '\\n';\n}\nOutput:
before calling set_subtype(42): {\"bytes\":[202,254,186,190],\"subtype\":null}\nafter calling set_subtype(42): {\"bytes\":[202,254,186,190],\"subtype\":42}\nSince version 3.8.0.
"},{"location":"api/byte_container_with_subtype/subtype/","title":"nlohmann::byte_container_with_subtype::subtype","text":"constexpr subtype_type subtype() const noexcept;\nReturns the numerical subtype of the value if it has a subtype. If it does not have a subtype, this function will return subtype_type(-1) as a sentinel value.
the numerical subtype of the binary value, or subtype_type(-1) if no subtype is set
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/byte_container_with_subtype/subtype/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/byte_container_with_subtype/subtype/#examples","title":"Examples","text":"ExampleThe example below demonstrates how the subtype can be retrieved with subtype. Note how subtype_type(-1) is returned for container c1.
#include <iostream>\n#include <nlohmann/json.hpp>\n\n// define a byte container based on std::vector\nusing byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;\n\nint main()\n{\n std::vector<std::uint8_t> bytes = {{0xca, 0xfe, 0xba, 0xbe}};\n\n // create container\n auto c1 = byte_container_with_subtype(bytes);\n\n // create container with subtype\n auto c2 = byte_container_with_subtype(bytes, 42);\n\n std::cout << \"c1.subtype() = \" << c1.subtype()\n << \"\\nc2.subtype() = \" << c2.subtype() << std::endl;\n\n // in case no subtype is set, return special value\n assert(c1.subtype() == static_cast<byte_container_with_subtype::subtype_type>(-1));\n}\nOutput:
c1.subtype() = 18446744073709551615\nc2.subtype() = 42\nsubtype_type(-1) as documented in version 3.10.0.template<typename RefStringType>\nclass json_pointer;\nA JSON pointer defines a string syntax for identifying a specific value within a JSON document. It can be used with functions at and operator[]. Furthermore, JSON pointers are the base for JSON patches.
RefStringType the string type used for the reference tokens making up the JSON pointer Deprecation
For backwards compatibility RefStringType may also be a specialization of basic_json in which case string_t will be deduced as basic_json::string_t. This feature is deprecated and may be removed in a future major version.
basic_json to string type in version 3.11.0.const string_t& back() const;\nReturn the last reference token.
"},{"location":"api/json_pointer/back/#return-value","title":"Return value","text":"Last reference token.
"},{"location":"api/json_pointer/back/#exceptions","title":"Exceptions","text":"Throws out_of_range.405 if the JSON pointer has no parent.
"},{"location":"api/json_pointer/back/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/json_pointer/back/#examples","title":"Examples","text":"ExampleThe example shows the usage of back.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON Pointers\n json::json_pointer ptr1(\"/foo\");\n json::json_pointer ptr2(\"/foo/0\");\n\n // call empty()\n std::cout << \"last reference token of \\\"\" << ptr1 << \"\\\" is \\\"\" << ptr1.back() << \"\\\"\\n\"\n << \"last reference token of \\\"\" << ptr2 << \"\\\" is \\\"\" << ptr2.back() << \"\\\"\" << std::endl;\n}\nOutput:
last reference token of \"/foo\" is \"foo\"\nlast reference token of \"/foo/0\" is \"0\"\nstring_t in version 3.11.0.bool empty() const noexcept;\nReturn whether the pointer points to the root document.
"},{"location":"api/json_pointer/empty/#return-value","title":"Return value","text":"true iff the JSON pointer points to the root document.
No-throw guarantee: this function never throws exceptions.
"},{"location":"api/json_pointer/empty/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/json_pointer/empty/#examples","title":"Examples","text":"ExampleThe example shows the result of empty for different JSON Pointers.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON Pointers\n json::json_pointer ptr0;\n json::json_pointer ptr1(\"\");\n json::json_pointer ptr2(\"/foo\");\n json::json_pointer ptr3(\"/foo/0\");\n\n // call empty()\n std::cout << std::boolalpha\n << \"\\\"\" << ptr0 << \"\\\": \" << ptr0.empty() << '\\n'\n << \"\\\"\" << ptr1 << \"\\\": \" << ptr1.empty() << '\\n'\n << \"\\\"\" << ptr2 << \"\\\": \" << ptr2.empty() << '\\n'\n << \"\\\"\" << ptr3 << \"\\\": \" << ptr3.empty() << std::endl;\n}\nOutput:
\"\": true\n\"\": true\n\"/foo\": false\n\"/foo/0\": false\nAdded in version 3.6.0.
"},{"location":"api/json_pointer/front/","title":"nlohmann::json_pointer::front","text":"const string_t& front() const;\nReturn the first reference token.
"},{"location":"api/json_pointer/front/#return-value","title":"Return value","text":"First reference token.
"},{"location":"api/json_pointer/front/#exceptions","title":"Exceptions","text":"Throws out_of_range.405 if the JSON pointer has no parent.
"},{"location":"api/json_pointer/front/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/json_pointer/front/#examples","title":"Examples","text":"ExampleThe example shows the usage of front.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON Pointers\n json::json_pointer ptr1(\"/foo\");\n json::json_pointer ptr2(\"/foo/0\");\n\n // call empty()\n std::cout << \"first reference token of \\\"\" << ptr1 << \"\\\" is \\\"\" << ptr1.front() << \"\\\"\\n\"\n << \"first reference token of \\\"\" << ptr2 << \"\\\" is \\\"\" << ptr2.front() << \"\\\"\" << std::endl;\n}\nOutput:
first reference token of \"/foo\" is \"foo\"\nfirst reference token of \"/foo/0\" is \"foo\"\nexplicit json_pointer(const string_t& s = \"\");\nCreate a JSON pointer according to the syntax described in Section 3 of RFC6901.
"},{"location":"api/json_pointer/json_pointer/#parameters","title":"Parameters","text":"s (in) string representing the JSON pointer; if omitted, the empty string is assumed which references the whole JSON value"},{"location":"api/json_pointer/json_pointer/#exceptions","title":"Exceptions","text":"s is nonempty and does not begin with a slash (/); see example below.~) in the given JSON pointer s is not followed by 0 (representing ~) or 1 (representing /); see example below.The example shows the construction several valid JSON pointers as well as the exceptional behavior.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // correct JSON pointers\n json::json_pointer p1;\n json::json_pointer p2(\"\");\n json::json_pointer p3(\"/\");\n json::json_pointer p4(\"//\");\n json::json_pointer p5(\"/foo/bar\");\n json::json_pointer p6(\"/foo/bar/-\");\n json::json_pointer p7(\"/foo/~0\");\n json::json_pointer p8(\"/foo/~1\");\n\n // error: JSON pointer does not begin with a slash\n try\n {\n json::json_pointer p9(\"foo\");\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // error: JSON pointer uses escape symbol ~ not followed by 0 or 1\n try\n {\n json::json_pointer p10(\"/foo/~\");\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n\n // error: JSON pointer uses escape symbol ~ not followed by 0 or 1\n try\n {\n json::json_pointer p11(\"/foo/~3\");\n }\n catch (const json::parse_error& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[json.exception.parse_error.107] parse error at byte 1: JSON pointer must be empty or begin with '/' - was: 'foo'\n[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'\n[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'\ns to string_t in version 3.11.0.// until C++20\ntemplate<typename RefStringTypeLhs, typename RefStringTypeRhs>\nbool operator==(\n const json_pointer<RefStringTypeLhs>& lhs,\n const json_pointer<RefStringTypeRhs>& rhs) noexcept; // (1)\n\ntemplate<typename RefStringTypeLhs, typename StringType>\nbool operator==(\n const json_pointer<RefStringTypeLhs>& lhs,\n const StringType& rhs); // (2)\n\ntemplate<typename RefStringTypeRhs, typename StringType>\nbool operator==(\n const StringType& lhs,\n const json_pointer<RefStringTypeRhs>& rhs); // (2)\n\n// since C++20\nclass json_pointer {\n template<typename RefStringTypeRhs>\n bool operator==(\n const json_pointer<RefStringTypeRhs>& rhs) const noexcept; // (1)\n\n bool operator==(const string_t& rhs) const; // (2)\n};\nCompares two JSON pointers for equality by comparing their reference tokens.
Compares a JSON pointer and a string or a string and a JSON pointer for equality by converting the string to a JSON pointer and comparing the JSON pointers according to 1.
RefStringTypeLhs, RefStringTypeRhs the string type of the left-hand side or right-hand side JSON pointer, respectively StringType the string type derived from the json_pointer operand (json_pointer::string_t)"},{"location":"api/json_pointer/operator_eq/#parameters","title":"Parameters","text":"lhs (in) first value to consider rhs (in) second value to consider"},{"location":"api/json_pointer/operator_eq/#return-value","title":"Return value","text":"whether the values lhs/*this and rhs are equal
s is nonempty and does not begin with a slash (/); see example below.~) in the given JSON pointer s is not followed by 0 (representing ~) or 1 (representing /); see example below.Constant if lhs and rhs differ in the number of reference tokens, otherwise linear in the number of reference tokens.
Deprecation
Overload 2 is deprecated and will be removed in a future major version release.
"},{"location":"api/json_pointer/operator_eq/#examples","title":"Examples","text":"Example: (1) Comparing JSON pointersThe example demonstrates comparing JSON pointers.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON pointers\n json::json_pointer ptr0;\n json::json_pointer ptr1(\"\");\n json::json_pointer ptr2(\"/foo\");\n\n // compare JSON pointers\n std::cout << std::boolalpha\n << \"\\\"\" << ptr0 << \"\\\" == \\\"\" << ptr0 << \"\\\": \" << (ptr0 == ptr0) << '\\n'\n << \"\\\"\" << ptr0 << \"\\\" == \\\"\" << ptr1 << \"\\\": \" << (ptr0 == ptr1) << '\\n'\n << \"\\\"\" << ptr1 << \"\\\" == \\\"\" << ptr2 << \"\\\": \" << (ptr1 == ptr2) << '\\n'\n << \"\\\"\" << ptr2 << \"\\\" == \\\"\" << ptr2 << \"\\\": \" << (ptr2 == ptr2) << std::endl;\n}\nOutput:
\"\" == \"\": true\n\"\" == \"\": true\n\"\" == \"/foo\": false\n\"/foo\" == \"/foo\": true\nThe example demonstrates comparing JSON pointers and strings, and when doing so may raise an exception.
#include <exception>\n#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON pointers\n json::json_pointer ptr0;\n json::json_pointer ptr1(\"\");\n json::json_pointer ptr2(\"/foo\");\n\n // different strings\n std::string str0(\"\");\n std::string str1(\"/foo\");\n std::string str2(\"bar\");\n\n // compare JSON pointers and strings\n std::cout << std::boolalpha\n << \"\\\"\" << ptr0 << \"\\\" == \\\"\" << str0 << \"\\\": \" << (ptr0 == str0) << '\\n'\n << \"\\\"\" << str0 << \"\\\" == \\\"\" << ptr1 << \"\\\": \" << (str0 == ptr1) << '\\n'\n << \"\\\"\" << ptr2 << \"\\\" == \\\"\" << str1 << \"\\\": \" << (ptr2 == str1) << std::endl;\n\n try\n {\n std::cout << \"\\\"\" << str2 << \"\\\" == \\\"\" << ptr2 << \"\\\": \" << (str2 == ptr2) << std::endl;\n }\n catch (const json::parse_error& ex)\n {\n std::cout << ex.what() << std::endl;\n }\n}\nOutput:
\"\" == \"\": true\n\"\" == \"\": true\n\"/foo\" == \"/foo\": true\n\"bar\" == \"/foo\": [json.exception.parse_error.107] parse error at byte 1: JSON pointer must be empty or begin with '/' - was: 'bar'\n// until C++20\ntemplate<typename RefStringTypeLhs, typename RefStringTypeRhs>\nbool operator!=(\n const json_pointer<RefStringTypeLhs>& lhs,\n const json_pointer<RefStringTypeRhs>& rhs) noexcept; // (1)\n\ntemplate<typename RefStringTypeLhs, typename StringType>\nbool operator!=(\n const json_pointer<RefStringTypeLhs>& lhs,\n const StringType& rhs); // (2)\n\ntemplate<typename RefStringTypeRhs, typename StringType>\nbool operator!=(\n const StringType& lhs,\n const json_pointer<RefStringTypeRhs>& rhs); // (2)\nCompares two JSON pointers for inequality by comparing their reference tokens.
Compares a JSON pointer and a string or a string and a JSON pointer for inequality by converting the string to a JSON pointer and comparing the JSON pointers according to 1.
RefStringTypeLhs, RefStringTypeRhs the string type of the left-hand side or right-hand side JSON pointer, respectively StringType the string type derived from the json_pointer operand (json_pointer::string_t)"},{"location":"api/json_pointer/operator_ne/#parameters","title":"Parameters","text":"lhs (in) first value to consider rhs (in) second value to consider"},{"location":"api/json_pointer/operator_ne/#return-value","title":"Return value","text":"whether the values lhs/*this and rhs are not equal
s is nonempty and does not begin with a slash (/); see example below.~) in the given JSON pointer s is not followed by 0 (representing ~) or 1 (representing /); see example below.Constant if lhs and rhs differ in the number of reference tokens, otherwise linear in the number of reference tokens.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator==.
Deprecation
Overload 2 is deprecated and will be removed in a future major version release.
"},{"location":"api/json_pointer/operator_ne/#examples","title":"Examples","text":"Example: (1) Comparing JSON pointersThe example demonstrates comparing JSON pointers.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON pointers\n json::json_pointer ptr0;\n json::json_pointer ptr1(\"\");\n json::json_pointer ptr2(\"/foo\");\n\n // compare JSON pointers\n std::cout << std::boolalpha\n << \"\\\"\" << ptr0 << \"\\\" != \\\"\" << ptr0 << \"\\\": \" << (ptr0 != ptr0) << '\\n'\n << \"\\\"\" << ptr0 << \"\\\" != \\\"\" << ptr1 << \"\\\": \" << (ptr0 != ptr1) << '\\n'\n << \"\\\"\" << ptr1 << \"\\\" != \\\"\" << ptr2 << \"\\\": \" << (ptr1 != ptr2) << '\\n'\n << \"\\\"\" << ptr2 << \"\\\" != \\\"\" << ptr2 << \"\\\": \" << (ptr2 != ptr2) << std::endl;\n}\nOutput:
\"\" != \"\": false\n\"\" != \"\": false\n\"\" != \"/foo\": true\n\"/foo\" != \"/foo\": false\nThe example demonstrates comparing JSON pointers and strings, and when doing so may raise an exception.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON pointers\n json::json_pointer ptr0;\n json::json_pointer ptr1(\"\");\n json::json_pointer ptr2(\"/foo\");\n\n // different strings\n std::string str0(\"\");\n std::string str1(\"/foo\");\n std::string str2(\"bar\");\n\n // compare JSON pointers and strings\n std::cout << std::boolalpha\n << \"\\\"\" << ptr0 << \"\\\" != \\\"\" << str0 << \"\\\": \" << (ptr0 != str0) << '\\n'\n << \"\\\"\" << str0 << \"\\\" != \\\"\" << ptr1 << \"\\\": \" << (str0 != ptr1) << '\\n'\n << \"\\\"\" << ptr2 << \"\\\" != \\\"\" << str1 << \"\\\": \" << (ptr2 != str1) << std::endl;\n\n try\n {\n std::cout << \"\\\"\" << str2 << \"\\\" != \\\"\" << ptr2 << \"\\\": \" << (str2 != ptr2) << std::endl;\n }\n catch (const json::parse_error& ex)\n {\n std::cout << ex.what() << std::endl;\n }\n}\nOutput:
\"\" != \"\": false\n\"\" != \"\": false\n\"/foo\" != \"/foo\": false\n\"bar\" != \"/foo\": [json.exception.parse_error.107] parse error at byte 1: JSON pointer must be empty or begin with '/' - was: 'bar'\n// (1)\njson_pointer operator/(const json_pointer& lhs, const json_pointer& rhs);\n\n// (2)\njson_pointer operator/(const json_pointer& lhs, string_t token);\n\n// (3)\njson_pointer operator/(const json_pointer& lhs, std::size_t array_idx);\nlhs (in) JSON pointer rhs (in) JSON pointer to append token (in) reference token to append array_idx (in) array index to append"},{"location":"api/json_pointer/operator_slash/#return-value","title":"Return value","text":"rhs appended to lhstoken appended to lhsarray_idx appended to lhslhs and rhs.lhs.lhs.The example shows the usage of operator/.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON pointer\n json::json_pointer ptr(\"/foo\");\n\n // append a JSON Pointer\n std::cout << \"\\\"\" << ptr / json::json_pointer(\"/bar/baz\") << \"\\\"\\n\";\n\n // append a string\n std::cout << \"\\\"\" << ptr / \"fob\" << \"\\\"\\n\";\n\n // append an array index\n std::cout << \"\\\"\" << ptr / 42 << \"\\\"\" << std::endl;\n}\nOutput:
\"/foo/bar/baz\"\n\"/foo/fob\"\n\"/foo/42\"\ntoken to string_t in version 3.11.0.// (1)\njson_pointer& operator/=(const json_pointer& ptr);\n\n// (2)\njson_pointer& operator/=(string_t token);\n\n// (3)\njson_pointer& operator/=(std::size_t array_idx)\nptr (in) JSON pointer to append token (in) reference token to append array_idx (in) array index to append"},{"location":"api/json_pointer/operator_slasheq/#return-value","title":"Return value","text":"ptr appendedtoken appended without escaping tokenarray_idx appendedptr.The example shows the usage of operator/=.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON pointer\n json::json_pointer ptr(\"/foo\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n // append a JSON Pointer\n ptr /= json::json_pointer(\"/bar/baz\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n // append a string\n ptr /= \"fob\";\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n // append an array index\n ptr /= 42;\n std::cout << \"\\\"\" << ptr << \"\\\"\" << std::endl;\n}\nOutput:
\"/foo\"\n\"/foo/bar/baz\"\n\"/foo/bar/baz/fob\"\n\"/foo/bar/baz/fob/42\"\ntoken to string_t in version 3.11.0.operator string_t() const\nReturn a string representation of the JSON pointer.
"},{"location":"api/json_pointer/operator_string_t/#return-value","title":"Return value","text":"A string representation of the JSON pointer
"},{"location":"api/json_pointer/operator_string_t/#possible-implementation","title":"Possible implementation","text":"operator string_t() const\n{\n return to_string();\n}\nDeprecation
This function is deprecated in favor of to_string and will be removed in a future major version release.
The example shows how JSON Pointers can be implicitly converted to strings.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON Pointers\n json::json_pointer ptr1(\"/foo/0\");\n json::json_pointer ptr2(\"/a~1b\");\n\n // implicit conversion to string\n std::string s;\n s += ptr1;\n s += \"\\n\";\n s += ptr2;\n\n std::cout << s << std::endl;\n}\nOutput:
/foo/0\n/a~1b\nstring_t and deprecated in version 3.11.0.json_pointer parent_pointer() const;\nReturns the parent of this JSON pointer.
"},{"location":"api/json_pointer/parent_pointer/#return-value","title":"Return value","text":"Parent of this JSON pointer; in case this JSON pointer is the root, the root itself is returned.
"},{"location":"api/json_pointer/parent_pointer/#exception-safety","title":"Exception safety","text":"No-throw guarantee: this function never throws exceptions.
"},{"location":"api/json_pointer/parent_pointer/#complexity","title":"Complexity","text":"Linear in the length of the JSON pointer.
"},{"location":"api/json_pointer/parent_pointer/#examples","title":"Examples","text":"ExampleThe example shows the result of parent_pointer for different JSON Pointers.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON Pointers\n json::json_pointer ptr1(\"\");\n json::json_pointer ptr2(\"/foo\");\n json::json_pointer ptr3(\"/foo/0\");\n\n // call parent_pointer()\n std::cout << std::boolalpha\n << \"parent of \\\"\" << ptr1 << \"\\\" is \\\"\" << ptr1.parent_pointer() << \"\\\"\\n\"\n << \"parent of \\\"\" << ptr2 << \"\\\" is \\\"\" << ptr2.parent_pointer() << \"\\\"\\n\"\n << \"parent of \\\"\" << ptr3 << \"\\\" is \\\"\" << ptr3.parent_pointer() << \"\\\"\" << std::endl;\n}\nOutput:
parent of \"\" is \"\"\nparent of \"/foo\" is \"\"\nparent of \"/foo/0\" is \"/foo\"\nAdded in version 3.6.0.
"},{"location":"api/json_pointer/pop_back/","title":"nlohmann::json_pointer::pop_back","text":"void pop_back();\nRemove the last reference token.
"},{"location":"api/json_pointer/pop_back/#exceptions","title":"Exceptions","text":"Throws out_of_range.405 if the JSON pointer has no parent.
"},{"location":"api/json_pointer/pop_back/#complexity","title":"Complexity","text":"Constant.
"},{"location":"api/json_pointer/pop_back/#examples","title":"Examples","text":"ExampleThe example shows the usage of pop_back.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create empty JSON Pointer\n json::json_pointer ptr(\"/foo/bar/baz\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n // call pop_back()\n ptr.pop_back();\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n ptr.pop_back();\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n ptr.pop_back();\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n}\nOutput:
\"/foo/bar/baz\"\n\"/foo/bar\"\n\"/foo\"\n\"\"\nAdded in version 3.6.0.
"},{"location":"api/json_pointer/pop_front/","title":"nlohmann::json_pointer::pop_front","text":"void pop_front();\nRemove the first reference token.
"},{"location":"api/json_pointer/pop_front/#exceptions","title":"Exceptions","text":"Throws out_of_range.405 if the JSON pointer has no parent.
"},{"location":"api/json_pointer/pop_front/#complexity","title":"Complexity","text":"Linear in the number of reference tokens in the json_pointer.
The example shows the usage of pop_front.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create empty JSON Pointer\n json::json_pointer ptr(\"/foo/bar/baz\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n // call pop_front()\n ptr.pop_front();\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n ptr.pop_front();\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n ptr.pop_front();\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n}\nOutput:
\"/foo/bar/baz\"\n\"/bar/baz\"\n\"/baz\"\n\"\"\nvoid push_back(const string_t& token);\n\nvoid push_back(string_t&& token);\nAppend an unescaped token at the end of the reference pointer.
"},{"location":"api/json_pointer/push_back/#parameters","title":"Parameters","text":"token (in) token to add"},{"location":"api/json_pointer/push_back/#complexity","title":"Complexity","text":"Amortized constant.
"},{"location":"api/json_pointer/push_back/#examples","title":"Examples","text":"ExampleThe example shows the result of push_back for different JSON Pointers.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create empty JSON Pointer\n json::json_pointer ptr;\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n // call push_back()\n ptr.push_back(\"foo\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n ptr.push_back(\"0\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n ptr.push_back(\"bar\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n}\nOutput:
\"\"\n\"/foo\"\n\"/foo/0\"\n\"/foo/0/bar\"\ntoken to string_t in version 3.11.0.void push_front(const string_t& token);\n\nvoid push_front(string_t&& token);\nAppend an unescaped token at the start of the reference pointer.
"},{"location":"api/json_pointer/push_front/#parameters","title":"Parameters","text":"token (in) token to add"},{"location":"api/json_pointer/push_front/#complexity","title":"Complexity","text":"Linear in the number of reference tokens in the json_pointer.
The example shows the result of push_front for different JSON Pointers.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create empty JSON Pointer\n json::json_pointer ptr;\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n // call push_front()\n ptr.push_front(\"foo\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n ptr.push_front(\"0\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n\n ptr.push_front(\"bar\");\n std::cout << \"\\\"\" << ptr << \"\\\"\\n\";\n}\nOutput:
\"\"\n\"/foo\"\n\"/0/foo\"\n\"/bar/0/foo\"\nusing string_t = RefStringType;\nThe string type used for the reference tokens making up the JSON pointer.
See basic_json::string_t for more information.
The example shows the type string_t and its relation to basic_json::string_t.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json::json_pointer::string_t s = \"This is a string.\";\n\n std::cout << s << std::endl;\n\n std::cout << std::boolalpha << std::is_same<json::json_pointer::string_t, json::string_t>::value << std::endl;\n}\nOutput:
This is a string.\ntrue\nstring_t to_string() const;\nReturn a string representation of the JSON pointer.
"},{"location":"api/json_pointer/to_string/#return-value","title":"Return value","text":"A string representation of the JSON pointer
"},{"location":"api/json_pointer/to_string/#notes","title":"Notes","text":"For each JSON pointer ptr, it holds:
ptr == json_pointer(ptr.to_string());\nThe example shows the result of to_string.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // different JSON Pointers\n json::json_pointer ptr1(\"\");\n json::json_pointer ptr2(\"/foo\");\n json::json_pointer ptr3(\"/foo/0\");\n json::json_pointer ptr4(\"/\");\n json::json_pointer ptr5(\"/a~1b\");\n json::json_pointer ptr6(\"/c%d\");\n json::json_pointer ptr7(\"/e^f\");\n json::json_pointer ptr8(\"/g|h\");\n json::json_pointer ptr9(\"/i\\\\j\");\n json::json_pointer ptr10(\"/k\\\"l\");\n json::json_pointer ptr11(\"/ \");\n json::json_pointer ptr12(\"/m~0n\");\n\n std::cout << \"\\\"\" << ptr1.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr2.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr3.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr4.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr5.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr6.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr7.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr8.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr9.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr10.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr11.to_string() << \"\\\"\\n\"\n << \"\\\"\" << ptr12.to_string() << \"\\\"\" << std::endl;\n}\nOutput:
\"\"\n\"/foo\"\n\"/foo/0\"\n\"/\"\n\"/a~1b\"\n\"/c%d\"\n\"/e^f\"\n\"/g|h\"\n\"/i\\j\"\n\"/k\"l\"\n\"/ \"\n\"/m~0n\"\nstring_t in version 3.11.0.template<typename BasicJsonType>\nstruct json_sax;\nThis class describes the SAX interface used by sax_parse. Each function is called in different situations while the input is parsed. The boolean return value informs the parser whether to continue processing the input.
"},{"location":"api/json_sax/#template-parameters","title":"Template parameters","text":"BasicJsonType a specialization of basic_json"},{"location":"api/json_sax/#member-types","title":"Member types","text":"BasicJsonType's type for numbers (integer)BasicJsonType's type for numbers (unsigned)BasicJsonType's type for numbers (floating-point)BasicJsonType's type for stringsBasicJsonType's type for binary arraysbinary_t, binary) added in version 3.8.0.virtual bool binary(binary_t& val) = 0;\nA binary value was read.
"},{"location":"api/json_sax/binary/#parameters","title":"Parameters","text":"val (in) binary value"},{"location":"api/json_sax/binary/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/binary/#notes","title":"Notes","text":"It is safe to move the passed binary value.
"},{"location":"api/json_sax/binary/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // CBOR byte string\n std::vector<std::uint8_t> vec = {{0x44, 0xcA, 0xfe, 0xba, 0xbe}};\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse CBOR\n bool result = json::sax_parse(vec, &sec, json::input_format_t::cbor);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
binary(val=[...])\n\nresult: true\nvirtual bool boolean(bool val) = 0;\nA boolean value was read.
"},{"location":"api/json_sax/boolean/#parameters","title":"Parameters","text":"val (in) boolean value"},{"location":"api/json_sax/boolean/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/boolean/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool end_array() = 0;\nThe end of an array was read.
"},{"location":"api/json_sax/end_array/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/end_array/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool end_object() = 0;\nThe end of an object was read.
"},{"location":"api/json_sax/end_object/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/end_object/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool key(string_t& val) = 0;\nAn object key was read.
"},{"location":"api/json_sax/key/#parameters","title":"Parameters","text":"val (in) object key"},{"location":"api/json_sax/key/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/key/#notes","title":"Notes","text":"It is safe to move the passed object key value.
"},{"location":"api/json_sax/key/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool null() = 0;\nA null value was read.
"},{"location":"api/json_sax/null/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/null/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool number_float(number_float_t val, const string_t& s) = 0;\nA floating-point number was read.
"},{"location":"api/json_sax/number_float/#parameters","title":"Parameters","text":"val (in) floating-point value s (in) string representation of the original input"},{"location":"api/json_sax/number_float/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/number_float/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool number_integer(number_integer_t val) = 0;\nAn integer number was read.
"},{"location":"api/json_sax/number_integer/#parameters","title":"Parameters","text":"val (in) integer value"},{"location":"api/json_sax/number_integer/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/number_integer/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool number_unsigned(number_unsigned_t val) = 0;\nAn unsigned integer number was read.
"},{"location":"api/json_sax/number_unsigned/#parameters","title":"Parameters","text":"val (in) unsigned integer value"},{"location":"api/json_sax/number_unsigned/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/number_unsigned/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool parse_error(std::size_t position,\n const std::string& last_token,\n const detail::exception& ex) = 0;\nA parse error occurred.
"},{"location":"api/json_sax/parse_error/#parameters","title":"Parameters","text":"position (in) the position in the input where the error occurs last_token (in) the last read token ex (in) an exception object describing the error"},{"location":"api/json_sax/parse_error/#return-value","title":"Return value","text":"Whether parsing should proceed (must return false).
The example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool start_array(std::size_t elements) = 0;\nThe beginning of an array was read.
"},{"location":"api/json_sax/start_array/#parameters","title":"Parameters","text":"elements (in) number of array elements, or std::numeric_limits<std::size_t>::max() if unknown"},{"location":"api/json_sax/start_array/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/start_array/#notes","title":"Notes","text":"Binary formats may report the number of elements.
"},{"location":"api/json_sax/start_array/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool start_object(std::size_t elements) = 0;\nThe beginning of an object was read.
"},{"location":"api/json_sax/start_object/#parameters","title":"Parameters","text":"elements (in) number of object elements, or std::numeric_limits<std::size_t>::max() if unknown"},{"location":"api/json_sax/start_object/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/start_object/#notes","title":"Notes","text":"Binary formats may report the number of elements.
"},{"location":"api/json_sax/start_object/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nvirtual bool string(string_t& val) = 0;\nA string value was read.
"},{"location":"api/json_sax/string/#parameters","title":"Parameters","text":"val (in) string value"},{"location":"api/json_sax/string/#return-value","title":"Return value","text":"Whether parsing should proceed.
"},{"location":"api/json_sax/string/#notes","title":"Notes","text":"It is safe to move the passed string value.
"},{"location":"api/json_sax/string/#examples","title":"Examples","text":"ExampleThe example below shows how the SAX interface is used.
#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n// a simple event consumer that collects string representations of the passed\n// values; note inheriting from json::json_sax_t is not required, but can\n// help not to forget a required function\nclass sax_event_consumer : public json::json_sax_t\n{\n public:\n std::vector<std::string> events;\n\n bool null() override\n {\n events.push_back(\"null()\");\n return true;\n }\n\n bool boolean(bool val) override\n {\n events.push_back(\"boolean(val=\" + std::string(val ? \"true\" : \"false\") + \")\");\n return true;\n }\n\n bool number_integer(number_integer_t val) override\n {\n events.push_back(\"number_integer(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_unsigned(number_unsigned_t val) override\n {\n events.push_back(\"number_unsigned(val=\" + std::to_string(val) + \")\");\n return true;\n }\n\n bool number_float(number_float_t val, const string_t& s) override\n {\n events.push_back(\"number_float(val=\" + std::to_string(val) + \", s=\" + s + \")\");\n return true;\n }\n\n bool string(string_t& val) override\n {\n events.push_back(\"string(val=\" + val + \")\");\n return true;\n }\n\n bool start_object(std::size_t elements) override\n {\n events.push_back(\"start_object(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_object() override\n {\n events.push_back(\"end_object()\");\n return true;\n }\n\n bool start_array(std::size_t elements) override\n {\n events.push_back(\"start_array(elements=\" + std::to_string(elements) + \")\");\n return true;\n }\n\n bool end_array() override\n {\n events.push_back(\"end_array()\");\n return true;\n }\n\n bool key(string_t& val) override\n {\n events.push_back(\"key(val=\" + val + \")\");\n return true;\n }\n\n bool binary(json::binary_t& val) override\n {\n events.push_back(\"binary(val=[...])\");\n return true;\n }\n\n bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override\n {\n events.push_back(\"parse_error(position=\" + std::to_string(position) + \", last_token=\" + last_token + \",\\n ex=\" + std::string(ex.what()) + \")\");\n return false;\n }\n};\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, -38793],\n \"DeletionDate\": null,\n \"Distance\": 12.723374634\n }\n }]\n )\";\n\n // create a SAX event consumer object\n sax_event_consumer sec;\n\n // parse JSON\n bool result = json::sax_parse(text, &sec);\n\n // output the recorded events\n for (auto& event : sec.events)\n {\n std::cout << event << \"\\n\";\n }\n\n // output the result of sax_parse\n std::cout << \"\\nresult: \" << std::boolalpha << result << std::endl;\n}\nOutput:
start_object(elements=18446744073709551615)\nkey(val=Image)\nstart_object(elements=18446744073709551615)\nkey(val=Width)\nnumber_unsigned(val=800)\nkey(val=Height)\nnumber_unsigned(val=600)\nkey(val=Title)\nstring(val=View from 15th Floor)\nkey(val=Thumbnail)\nstart_object(elements=18446744073709551615)\nkey(val=Url)\nstring(val=http://www.example.com/image/481989943)\nkey(val=Height)\nnumber_unsigned(val=125)\nkey(val=Width)\nnumber_unsigned(val=100)\nend_object()\nkey(val=Animated)\nboolean(val=false)\nkey(val=IDs)\nstart_array(elements=18446744073709551615)\nnumber_unsigned(val=116)\nnumber_unsigned(val=943)\nnumber_unsigned(val=234)\nnumber_integer(val=-38793)\nend_array()\nkey(val=DeletionDate)\nnull()\nkey(val=Distance)\nnumber_float(val=12.723375, s=12.723374634)\nend_object()\nend_object()\nparse_error(position=460, last_token=12.723374634<U+000A> }<U+000A> }],\n ex=[json.exception.parse_error.101] parse error at line 17, column 6: syntax error while parsing value - unexpected ']'; expected end of input)\n\nresult: false\nSome aspects of the library can be configured by defining preprocessor macros before including the json.hpp header. See also the macro overview page.
std::filesystem supportstd::ranges supportstd::format/std::formatter supportnlohmann namespaceNLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE - serialize a non-derived class
NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE - serialize/deserialize a derived class with private members
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES - serialize a non-derived class; uses custom names
NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_NAMES - serialize/deserialize a derived class with private members; uses custom names
#define JSON_ASSERT(x) /* value */\nThis macro controls which code is executed for runtime assertions of the library.
"},{"location":"api/macros/json_assert/#parameters","title":"Parameters","text":"x (in) expression of a scalar type"},{"location":"api/macros/json_assert/#default-definition","title":"Default definition","text":"The default value is assert(x).
#define JSON_ASSERT(x) assert(x)\nTherefore, assertions can be switched off by defining NDEBUG.
const object). See page runtime assertions for more information.std::abort may leave the library in an undefined state.The following code will trigger an assertion at runtime:
#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n const json j = {{\"key\", \"value\"}};\n auto v = j[\"missing\"];\n}\nOutput:
Assertion failed: (m_value.object->find(key) != m_value.object->end()), function operator[], file json.hpp, line 2144.\nThe assertion reporting can be changed by defining JSON_ASSERT(x) differently.
#include <cstdio>\n#include <cstdlib>\n#define JSON_ASSERT(x) if(!(x)){fprintf(stderr, \"assertion error in %s\\n\", __FUNCTION__); std::abort();}\n\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n const json j = {{\"key\", \"value\"}};\n auto v = j[\"missing\"];\n}\nOutput:
assertion error in operator[]\n#define JSON_BRACE_INIT_COPY_SEMANTICS /* value */\nWhen defined to 1, single-element brace initialization of a basic_json value is treated as a copy/move of the element rather than wrapping it in a single-element array.
The default value is 0 (disabled \u2014 existing behavior is preserved).
#define JSON_BRACE_INIT_COPY_SEMANTICS 0\nBackground
C++ always prefers the initializer_list constructor over the copy/move constructor for brace initialization. This means that code like
json obj = {{\"key\", \"value\"}};\njson j{obj};\ncreates a single-element array [{\"key\":\"value\"}] instead of a copy of obj. This behavior is compiler-dependent for older compilers (GCC wrapped, Clang did not), but starting from Clang 20, both compilers behave the same way.
Enabling this macro opts into copy/move semantics for this case (see #5074).
Opt-in only
This macro must be defined before including <nlohmann/json.hpp>. Defining it after the include has no effect.
Workaround without the macro
To explicitly create a single-element array without enabling this macro, use json::array():
json j = json::array({obj}); // always creates [obj]\nWithout the macro, single-element brace initialization wraps the value in an array:
#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json obj = {{\"key\", \"value\"}};\n\n json j{obj};\n // j is [{\"key\":\"value\"}] -- single-element array, NOT a copy of obj\n}\nWith the macro, single-element brace initialization copies/moves the value:
#define JSON_BRACE_INIT_COPY_SEMANTICS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json obj = {{\"key\", \"value\"}};\n\n json j{obj};\n // j is {\"key\":\"value\"} -- copy of obj\n}\n#define JSON_DIAGNOSTIC_POSITIONS /* value */\nThis macro enables position diagnostics for generated JSON objects.
When enabled, two new member functions start_pos() and end_pos() are added to basic_json values. If the value was created by calling theparse function, then these functions allow querying the byte positions of the value in the input it was parsed from. In case the value was constructed by other means, std::string::npos is returned.
start_pos() returns the position of the first character of a given value in the original JSON string, while end_pos() returns the position of the character following the last character. For objects and arrays, the first and last characters correspond to the opening or closing braces/brackets, respectively. For primitive values, the first and last character represents the opening and closing quotes (strings) or the first and last character of the field's numerical or predefined value (true, false, null), respectively.
start_pos() return value end_pos() object position of the opening { position after the closing } array position of the opening [ position after the closing ] string position of the opening \" position after the closing \" number position of the first character position after the last character boolean position of t for true and f for false position after e null position of n position after l Given the above, end_pos()-start_pos() for a JSON value provides the length of the parsed JSON string for that value, including the opening or closing braces, brackets, or quotes.
Note that enabling this macro increases the size of every JSON value by two std::size_t fields and adds slight runtime overhead to parsing, copying JSON value objects, and the generation of error messages for exceptions. It also causes these values to be reported in those error messages.
The default value is 0 (position diagnostics are switched off).
#define JSON_DIAGNOSTIC_POSITIONS 0\nWhen the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/json_diagnostic_positions/#notes","title":"Notes","text":"CMake option
Diagnostic positions can also be controlled with the CMake option JSON_Diagnostic_Positions (OFF by default) which defines JSON_DIAGNOSTIC_POSITIONS accordingly.
Availability
Diagnostic positions are only available if the value was created by the parse function. The sax_parse function or all other means to create a JSON value do not set the diagnostic positions and start_pos() and end_pos() will only return std::string::npos for these values.
Invalidation
The returned positions are only valid as long as the JSON value is not changed. The positions are not updated when the JSON value is changed.
"},{"location":"api/macros/json_diagnostic_positions/#examples","title":"Examples","text":"Example: retrieving positions#include <iostream>\n\n#define JSON_DIAGNOSTIC_POSITIONS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::string json_string = R\"(\n {\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\n )\";\n json j = json::parse(json_string);\n\n std::cout << \"Root diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos: \" << j.start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j.end_pos() << \"\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"{\\n \\\"address\\\": {\\n \\\"street\\\": \\\"Fake Street\\\",\\n \\\"housenumber\\\": 1\\n }\\n }\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j.start_pos(), j.end_pos() - j.start_pos()) << \"\\n\\n\";\n\n std::cout << \"address diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"{ \\\"street\\\": \\\"Fake Street\\\",\\n \\\"housenumber\\\": 1\\n }\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"].start_pos(), j[\"address\"].end_pos() - j[\"address\"].start_pos()) << \"\\n\\n\";\n\n std::cout << \"street diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"][\"street\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"][\"street\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"\\\"Fake Street\\\"\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"][\"street\"].start_pos(), j[\"address\"][\"street\"].end_pos() - j[\"address\"][\"street\"].start_pos()) << \"\\n\\n\";\n\n std::cout << \"housenumber diagnostic positions: \\n\";\n std::cout << \"\\tstart_pos:\" << j[\"address\"][\"housenumber\"].start_pos() << '\\n';\n std::cout << \"\\tend_pos:\" << j[\"address\"][\"housenumber\"].end_pos() << \"\\n\\n\";\n std::cout << \"Original string: \\n\";\n std::cout << \"1\" << \"\\n\";\n std::cout << \"Parsed string: \\n\";\n std::cout << json_string.substr(j[\"address\"][\"housenumber\"].start_pos(), j[\"address\"][\"housenumber\"].end_pos() - j[\"address\"][\"housenumber\"].start_pos()) << \"\\n\\n\";\n}\nOutput:
Root diagnostic positions: \n start_pos: 5\n end_pos:109\nOriginal string: \n{\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\nParsed string: \n{\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n }\n\naddress diagnostic positions: \n start_pos:26\n end_pos:103\n\nOriginal string: \n{ \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\nParsed string: \n{\n \"street\": \"Fake Street\",\n \"housenumber\": 1\n }\n\nstreet diagnostic positions: \n start_pos:50\n end_pos:63\n\nOriginal string: \n\"Fake Street\"\nParsed string: \n\"Fake Street\"\n\nhousenumber diagnostic positions: \n start_pos:92\n end_pos:93\n\nOriginal string: \n1\nParsed string: \n1\nThe output shows the start/end positions of all the objects and fields in the JSON string.
Example 2: using only diagnostic positions in exceptions#include <iostream>\n\n#define JSON_DIAGNOSTIC_POSITIONS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n/* Demonstration of type error exception with diagnostic positions support enabled */\nint main()\n{\n //Invalid json string - housenumber type must be int instead of string\n const std::string json_invalid_string = R\"(\n {\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": \"1\"\n }\n }\n )\";\n json j = json::parse(json_invalid_string);\n try\n {\n int housenumber = j[\"address\"][\"housenumber\"];\n std::cout << housenumber;\n }\n catch (const json::exception& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[json.exception.type_error.302] (bytes 92-95) type must be number, but is string\nThe output shows the exception with start/end positions only.\n#include <iostream>\n\n#define JSON_DIAGNOSTICS 1\n#define JSON_DIAGNOSTIC_POSITIONS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n/* Demonstration of type error exception with diagnostic positions support enabled */\nint main()\n{\n //Invalid json string - housenumber type must be int instead of string\n const std::string json_invalid_string = R\"(\n {\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": \"1\"\n }\n }\n )\";\n json j = json::parse(json_invalid_string);\n try\n {\n int housenumber = j[\"address\"][\"housenumber\"];\n std::cout << housenumber;\n }\n catch (const json::exception& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[json.exception.type_error.302] (/address/housenumber) (bytes 92-95) type must be number, but is string\nThe output shows the exception with diagnostic path info and start/end positions.\n#define JSON_DIAGNOSTICS /* value */\nThis macro enables extended diagnostics for exception messages. Possible values are 1 to enable or 0 to disable (default).
When enabled, exception messages contain a JSON Pointer to the JSON value that triggered the exception. Note that enabling this macro increases the size of every JSON value by one pointer and adds some runtime overhead.
"},{"location":"api/macros/json_diagnostics/#default-definition","title":"Default definition","text":"The default value is 0 (extended diagnostics are switched off).
#define JSON_DIAGNOSTICS 0\nWhen the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/json_diagnostics/#notes","title":"Notes","text":"ABI compatibility
As of version 3.11.0, this macro is no longer required to be defined consistently throughout a codebase to avoid One Definition Rule (ODR) violations, as the value of this macro is encoded in the namespace, resulting in distinct symbol names.
This allows different parts of a codebase to use different versions or configurations of this library without causing improper behavior.
Where possible, it is still recommended that all code define this the same way for maximum interoperability.
CMake option
Diagnostic messages can also be controlled with the CMake option JSON_Diagnostics (OFF by default) which defines JSON_DIAGNOSTICS accordingly.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j;\n j[\"address\"][\"street\"] = \"Fake Street\";\n j[\"address\"][\"housenumber\"] = \"12\";\n\n try\n {\n int housenumber = j[\"address\"][\"housenumber\"];\n }\n catch (const json::exception& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[json.exception.type_error.302] type must be number, but is string\nThis exception can be hard to debug if storing the value \"12\" and accessing it is further apart.
#include <iostream>\n\n# define JSON_DIAGNOSTICS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j;\n j[\"address\"][\"street\"] = \"Fake Street\";\n j[\"address\"][\"housenumber\"] = \"12\";\n\n try\n {\n int housenumber = j[\"address\"][\"housenumber\"];\n }\n catch (const json::exception& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[json.exception.type_error.302] (/address/housenumber) type must be number, but is string\nNow the exception message contains a JSON Pointer /address/housenumber that indicates which value has the wrong type.
#include <iostream>\n\n#define JSON_DIAGNOSTIC_POSITIONS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\n/* Demonstration of type error exception with diagnostic positions support enabled */\nint main()\n{\n //Invalid json string - housenumber type must be int instead of string\n const std::string json_invalid_string = R\"(\n {\n \"address\": {\n \"street\": \"Fake Street\",\n \"housenumber\": \"1\"\n }\n }\n )\";\n json j = json::parse(json_invalid_string);\n try\n {\n int housenumber = j[\"address\"][\"housenumber\"];\n std::cout << housenumber;\n }\n catch (const json::exception& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[json.exception.type_error.302] (bytes 92-95) type must be number, but is string\n#define JSON_DISABLE_ENUM_SERIALIZATION /* value */\nWhen defined to 1, default serialization and deserialization functions for enums are excluded and have to be provided by the user, for example, using NLOHMANN_JSON_SERIALIZE_ENUM (see arbitrary type conversions for more details).
Parsing or serializing an enum will result in a compiler error.
This works for both unscoped and scoped enums.
"},{"location":"api/macros/json_disable_enum_serialization/#default-definition","title":"Default definition","text":"The default value is 0.
#define JSON_DISABLE_ENUM_SERIALIZATION 0\nCMake option
Enum serialization can also be controlled with the CMake option JSON_DisableEnumSerialization (OFF by default) which defines JSON_DISABLE_ENUM_SERIALIZATION accordingly.
The code below forces the library not to create default serialization/deserialization functions from_json and to_json, meaning the code below does not compile.
#define JSON_DISABLE_ENUM_SERIALIZATION 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nenum class Choice\n{\n first,\n second,\n};\n\nint main()\n{\n // normally invokes to_json serialization function but with JSON_DISABLE_ENUM_SERIALIZATION defined, it does not\n const json j = Choice::first; \n\n // normally invokes from_json parse function but with JSON_DISABLE_ENUM_SERIALIZATION defined, it does not\n Choice ch = j.get<Choice>();\n}\nThe code below forces the library not to create default serialization/deserialization functions from_json and to_json, but uses NLOHMANN_JSON_SERIALIZE_ENUM to parse and serialize the enum.
#define JSON_DISABLE_ENUM_SERIALIZATION 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nenum class Choice\n{\n first,\n second,\n};\n\nNLOHMANN_JSON_SERIALIZE_ENUM(Choice,\n{\n { Choice::first, \"first\" },\n { Choice::second, \"second\" },\n})\n\nint main()\n{\n // uses user-defined to_json function defined by macro\n const json j = Choice::first; \n\n // uses user-defined from_json function defined by macro\n Choice ch = j.get<Choice>();\n}\nThe code below forces the library not to create default serialization/deserialization functions from_json and to_json, but uses user-defined functions to parse and serialize the enum.
#define JSON_DISABLE_ENUM_SERIALIZATION 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nenum class Choice\n{\n first,\n second,\n};\n\nvoid from_json(const json& j, Choice& ch)\n{\n auto value = j.get<std::string>();\n if (value == \"first\")\n {\n ch = Choice::first;\n }\n else if (value == \"second\")\n {\n ch = Choice::second;\n }\n}\n\nvoid to_json(json& j, const Choice& ch)\n{\n if (ch == Choice::first)\n {\n j = \"first\";\n }\n else if (ch == Choice::second)\n {\n j = \"second\";\n }\n}\n\nint main()\n{\n // uses user-defined to_json function\n const json j = Choice::first; \n\n // uses user-defined from_json function\n Choice ch = j.get<Choice>();\n}\nNLOHMANN_JSON_SERIALIZE_ENUM - serialize/deserialize an enum#define JSON_HAS_CPP_11\n#define JSON_HAS_CPP_14\n#define JSON_HAS_CPP_17\n#define JSON_HAS_CPP_20\n#define JSON_HAS_CPP_23\n#define JSON_HAS_CPP_26\nThe library targets C++11, but also supports some features introduced in later C++ versions (e.g., std::string_view support for C++17). For these new features, the library implements some preprocessor checks to determine the C++ standard. By defining any of these symbols, the internal check is overridden and the provided C++ version is unconditionally assumed. This can be helpful for compilers that only implement parts of the standard and would be detected incorrectly.
The default value is detected based on preprocessor macros such as __cplusplus, _HAS_CXX17, or _MSVC_LANG.
JSON_HAS_CPP_11 is always defined. When you override the detection by defining one of these macros manually, the automatic detection is skipped entirely, so you should define all applicable macros (including JSON_HAS_CPP_11) yourself.The code below forces the library to use the C++14 standard:
#define JSON_HAS_CPP_14 1\n#include <nlohmann/json.hpp>\n\n...\nJSON_HAS_CPP_23 in version 3.12.0.JSON_HAS_CPP_26 in version 3.12.x.#define JSON_HAS_FILESYSTEM /* value */\n#define JSON_HAS_EXPERIMENTAL_FILESYSTEM /* value */\nWhen compiling with C++17, the library provides conversions from and to std::filesystem::path. As compiler support for filesystem is limited, the library tries to detect whether <filesystem>/std::filesystem (JSON_HAS_FILESYSTEM) or <experimental/filesystem>/std::experimental::filesystem (JSON_HAS_EXPERIMENTAL_FILESYSTEM) should be used. To override the built-in check, define JSON_HAS_FILESYSTEM or JSON_HAS_EXPERIMENTAL_FILESYSTEM to 1.
The default value is detected based on the preprocessor macros __cpp_lib_filesystem, __cpp_lib_experimental_filesystem, __has_include(<filesystem>), or __has_include(<experimental/filesystem>).
stdc++fs to be linked to for filesystem support.The code below forces the library to use the header <experimental/filesystem>.
#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1\n#include <nlohmann/json.hpp>\n\n...\n#define JSON_HAS_RANGES /* value */\nThis macro indicates whether the standard library has any support for ranges. Implies support for concepts. Possible values are 1 when supported or 0 when unsupported.
The default value is detected based on the preprocessor macro __cpp_lib_ranges.
When the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/json_has_ranges/#examples","title":"Examples","text":"ExampleThe code below forces the library to enable support for ranges:
#define JSON_HAS_RANGES 1\n#include <nlohmann/json.hpp>\n\n...\n#define JSON_HAS_STATIC_RTTI /* value */\nThis macro indicates whether the standard library has any support for RTTI (run time type information). Possible values are 1 when supported or 0 when unsupported.
The default value is detected based on the preprocessor macro _HAS_STATIC_RTTI.
When the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/json_has_static_rtti/#examples","title":"Examples","text":"ExampleThe code below forces the library to enable support for libraries with RTTI dependence:
#define JSON_HAS_STATIC_RTTI 1\n#include <nlohmann/json.hpp>\n\n...\n#define JSON_HAS_STD_FORMAT /* value */\nThis macro indicates whether the standard library has support for std::format/std::formatter (that is, the <format> header). Possible values are 1 when supported or 0 when unsupported.
The default value is detected based on the preprocessor macros JSON_HAS_CPP_20 and __cpp_lib_format.
When the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/json_has_std_format/#notes","title":"Notes","text":"Enabled functionality
When this macro evaluates to 1, the library provides a std::formatter<basic_json> specialization so JSON values can be used directly with std::format.
The code below forces the library to disable support for std::format, even if the standard library would otherwise support it:
#define JSON_HAS_STD_FORMAT 0\n#include <nlohmann/json.hpp>\n\n...\n#define JSON_HAS_THREE_WAY_COMPARISON /* value */\nThis macro indicates whether the compiler and standard library support 3-way comparison. Possible values are 1 when supported or 0 when unsupported.
The default value is detected based on the preprocessor macros __cpp_impl_three_way_comparison and __cpp_lib_three_way_comparison.
When the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/json_has_three_way_comparison/#examples","title":"Examples","text":"ExampleThe code below forces the library to use 3-way comparison:
#define JSON_HAS_THREE_WAY_COMPARISON 1\n#include <nlohmann/json.hpp>\n\n...\n#define JSON_NO_IO\nWhen defined, headers <cstdio>, <ios>, <iosfwd>, <istream>, and <ostream> are not included and parse functions relying on these headers are excluded. This is relevant for environments where these I/O functions are disallowed for security reasons (e.g., Intel Software Guard Extensions (SGX)).
By default, JSON_NO_IO is not defined.
#undef JSON_NO_IO\nThe code below forces the library not to use the headers <cstdio>, <ios>, <iosfwd>, <istream>, and <ostream>.
#define JSON_NO_IO 1\n#include <nlohmann/json.hpp>\n\n...\n#define JSON_NOEXCEPTION\nExceptions can be switched off by defining the symbol JSON_NOEXCEPTION. When defining JSON_NOEXCEPTION, try is replaced by if (true), catch is replaced by if (false), and throw is replaced by std::abort().
The same effect is achieved by setting the compiler flag -fno-exceptions.
By default, the macro is not defined.
#undef JSON_NOEXCEPTION\nThe explanatory what() string of exceptions is not available for MSVC if exceptions are disabled, see #2824.
The code below switches off exceptions in the library.
#define JSON_NOEXCEPTION 1\n#include <nlohmann/json.hpp>\n\n...\nAdded in version 2.1.0.
"},{"location":"api/macros/json_skip_library_version_check/","title":"JSON_SKIP_LIBRARY_VERSION_CHECK","text":"#define JSON_SKIP_LIBRARY_VERSION_CHECK\nWhen defined, the library will not create a compiler warning when a different version of the library was already included.
"},{"location":"api/macros/json_skip_library_version_check/#default-definition","title":"Default definition","text":"By default, the macro is not defined.
#undef JSON_SKIP_LIBRARY_VERSION_CHECK\nABI compatibility
Mixing different library versions in the same code can be a problem as the different versions may not be ABI compatible.
"},{"location":"api/macros/json_skip_library_version_check/#examples","title":"Examples","text":"ExampleThe code below switches off the warning about including a different version of the library.
#define JSON_SKIP_LIBRARY_VERSION_CHECK 1\n#include <nlohmann/json.hpp>\n\n...\nExample
The following warning will be shown in case a different version of the library was already included:
Already included a different version of the library!\nAdded in version 3.11.0.
"},{"location":"api/macros/json_skip_unsupported_compiler_check/","title":"JSON_SKIP_UNSUPPORTED_COMPILER_CHECK","text":"#define JSON_SKIP_UNSUPPORTED_COMPILER_CHECK\nWhen defined, the library will not create a compile error when a known unsupported compiler is detected. This allows using the library with compilers that do not fully support C++11 and may only work if unsupported features are not used.
"},{"location":"api/macros/json_skip_unsupported_compiler_check/#default-definition","title":"Default definition","text":"By default, the macro is not defined.
#undef JSON_SKIP_UNSUPPORTED_COMPILER_CHECK\nThe code below switches off the check whether the compiler is supported.
#define JSON_SKIP_UNSUPPORTED_COMPILER_CHECK 1\n#include <nlohmann/json.hpp>\n\n...\nAdded in version 3.2.0.
"},{"location":"api/macros/json_throw_user/","title":"JSON_CATCH_USER, JSON_THROW_USER, JSON_TRY_USER","text":"// (1)\n#define JSON_CATCH_USER(exception) /* value */\n// (2)\n#define JSON_THROW_USER(exception) /* value */\n// (3)\n#define JSON_TRY_USER /* value */\nControls how exceptions are handled by the library.
catch calls inside the library. The argument is the type of the exception to catch. As of version 3.8.0, the library only catches std::out_of_range exceptions internally to rethrow them as json::out_of_range exceptions. The macro is always followed by a scope.throw calls inside the library. The argument is the exception to be thrown. Note that JSON_THROW_USER should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield undefined behavior.try calls inside the library. It has no arguments and is always followed by a scope.exception (in) an exception type"},{"location":"api/macros/json_throw_user/#default-definition","title":"Default definition","text":"By default, the macros map to their respective C++ keywords:
#define JSON_CATCH_USER(exception) catch(exception)\n#define JSON_THROW_USER(exception) throw exception\n#define JSON_TRY_USER try\nWhen exceptions are switched off, the try block is executed unconditionally, and throwing exceptions is replaced by calling std::abort to make reaching the throw branch abort the process.
#define JSON_THROW_USER(exception) std::abort()\n#define JSON_TRY_USER if (true)\n#define JSON_CATCH_USER(exception) if (false)\nThe code below switches off exceptions and creates a log entry with a detailed error message in case of errors.
#include <iostream>\n\n#define JSON_TRY_USER if(true)\n#define JSON_CATCH_USER(exception) if(false)\n#define JSON_THROW_USER(exception) \\\n {std::clog << \"Error in \" << __FILE__ << \":\" << __LINE__ \\\n << \" (function \" << __FUNCTION__ << \") - \" \\\n << (exception).what() << std::endl; \\\n std::abort();}\n\n#include <nlohmann/json.hpp>\n#define JSON_USE_GLOBAL_UDLS /* value */\nWhen defined to 1, the user-defined string literals (UDLs) are placed into the global namespace instead of nlohmann::literals::json_literals.
The default value is 1.
#define JSON_USE_GLOBAL_UDLS 1\nWhen the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/json_use_global_udls/#notes","title":"Notes","text":"Future behavior change
The user-defined string literals will be removed from the global namespace in the next major release of the library.
To prepare existing code, define JSON_USE_GLOBAL_UDLS to 0 and bring the string literals into scope where needed. Refer to any of the string literals for details.
CMake option
The placement of user-defined string literals can also be controlled with the CMake option JSON_GlobalUDLs (ON by default) which defines JSON_USE_GLOBAL_UDLS accordingly.
The code below shows the default behavior using the _json UDL.
#include <nlohmann/json.hpp>\n\n#include <iostream>\n\nint main()\n{\n auto j = \"42\"_json;\n\n std::cout << j << std::endl;\n}\nOutput:
42\nThe code below shows how UDLs need to be brought into scope before using _json when JSON_USE_GLOBAL_UDLS is defined to 0.
#define JSON_USE_GLOBAL_UDLS 0\n#include <nlohmann/json.hpp>\n\n#include <iostream>\n\nint main()\n{\n // auto j = \"42\"_json; // This line would fail to compile,\n // because the UDLs are not in the global namespace\n\n // Bring the UDLs into scope\n using namespace nlohmann::json_literals;\n\n auto j = \"42\"_json;\n\n std::cout << j << std::endl;\n}\nOutput:
42\noperator\"\"_jsonoperator\"\"_json_pointer#define JSON_USE_IMPLICIT_CONVERSIONS /* value */\nWhen defined to 0, implicit conversions are switched off. By default, implicit conversions are switched on. The value directly affects operator ValueType.
By default, implicit conversions are enabled.
#define JSON_USE_IMPLICIT_CONVERSIONS 1\nFuture behavior change
Implicit conversions will be switched off by default in the next major release of the library.
You can prepare existing code by already defining JSON_USE_IMPLICIT_CONVERSIONS to 0 and replace any implicit conversions with calls to get.
CMake option
Implicit conversions can also be controlled with the CMake option JSON_ImplicitConversions (ON by default) which defines JSON_USE_IMPLICIT_CONVERSIONS accordingly.
This is an example for an implicit conversion:
json j = \"Hello, world!\";\nstd::string s = j;\nWhen JSON_USE_IMPLICIT_CONVERSIONS is defined to 0, the code above does no longer compile. Instead, it must be written like this:
json j = \"Hello, world!\";\nauto s = j.get<std::string>();\n#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON /* value */\nThis macro enables the (incorrect) legacy comparison behavior of discarded JSON values. Possible values are 1 to enable or 0 to disable (default).
When enabled, comparisons involving at least one discarded JSON value yield results as follows:
Operator Result== false != true < false <= true >= true > false Otherwise, comparisons involving at least one discarded JSON value always yield false.
The default value is 0.
#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0\nWhen the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/json_use_legacy_discarded_value_comparison/#notes","title":"Notes","text":"Inconsistent behavior in C++20 and beyond
When targeting C++20 or above, enabling the legacy comparison behavior is strongly discouraged.
<=>) will always give the correct result (std::partial_ordering::unordered) regardless of the value of JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON.Code outside your control may use either 3-way comparison or the equality and relational operators, resulting in inconsistent and unpredictable behavior.
See operator<=> for more information on 3-way comparison.
Deprecation
The legacy comparison behavior is deprecated and may be removed in a future major version release.
New code should not depend on it and existing code should try to remove or rewrite expressions relying on it.
CMake option
Legacy comparison can also be controlled with the CMake option JSON_LegacyDiscardedValueComparison (OFF by default) which defines JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON accordingly.
The code below switches on the legacy discarded value comparison behavior in the library.
#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 1\n#include <nlohmann/json.hpp>\n\n...\n// (1)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(type, base_type, member...)\n// (2)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(type, base_type, member...)\n// (3)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(type, base_type, member...)\n\n// (4)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(type, base_type, member...)\n// (5)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(type, base_type, member...)\n// (6)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(type, base_type, member...)\nThese macros can be used to simplify the serialization/deserialization of derived types if you want to use a JSON object as serialization and want to use the member variable names as object keys in that object.
NLOHMANN_DEFINE_TYPE_INTRUSIVE, they can access private members.NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, they cannot access private members.The first parameter is the name of the derived class/struct, the second parameter is the name of the base class/struct and all remaining parameters name the members. The base type must be already serializable/deserializable.
at during deserialization and will throw out_of_range.403 if a key is missing in the JSON object.value during deserialization and fall back to the default value for the respective type of the member variable if a key in the JSON object is missing. The generated from_json() function default constructs an object and uses its values as the defaults when calling the value function.Summary:
Need access to private members Need only serialization Allow missing values when de-serializing macro NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE"},{"location":"api/macros/nlohmann_define_derived_type/#parameters","title":"Parameters","text":"type (in) name of the type (class, struct) to serialize/deserialize base_type (in) name of the base type (class, struct) type is derived from member (in) name of the member variable to serialize/deserialize; up to 63 members can be given as a comma-separated list"},{"location":"api/macros/nlohmann_define_derived_type/#default-definition","title":"Default definition","text":"Macros 1 and 2 add two friend functions to the class which take care of the serialization and deserialization:
template<typename BasicJsonType>\nfriend void to_json(BasicJsonType&, const type&);\ntemplate<typename BasicJsonType>\nfriend void from_json(const BasicJsonType&, type&);\nMacros 4 and 5 add two functions to the namespace which take care of the serialization and deserialization:
template<typename BasicJsonType>\nvoid to_json(BasicJsonType&, const type&);\ntemplate<typename BasicJsonType>\nvoid from_json(const BasicJsonType&, type&);\nMacros 3 and 6 add one function to the namespace, which takes care of the serialization only:
template<typename BasicJsonType>\nvoid to_json(BasicJsonType&, const type&);\nIn first two cases, they call the to_json/from_json functions of the base type before serializing/deserializing the members of the derived type:
class A { /* ... */ };\nclass B : public A { /* ... */ };\n\ntemplate<typename BasicJsonType>\nvoid to_json(BasicJsonType& j, const B& b) {\n nlohmann::to_json(j, static_cast<const A&>(b));\n // ...\n}\n\ntemplate<typename BasicJsonType>\nvoid from_json(const BasicJsonType& j, B& b) {\n nlohmann::from_json(j, static_cast<A&>(b));\n // ...\n}\nIn the third case, only to_json will be called:
class A { /* ... */ };\nclass B : public A { /* ... */ };\n\ntemplate<typename BasicJsonType>\nvoid to_json(BasicJsonType& j, const B& b) {\n nlohmann::to_json(j, static_cast<const A&>(b));\n // ...\n}\nPrerequisites
Implementation limits
See Implementation limits for NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, respectively.
"},{"location":"api/macros/nlohmann_define_derived_type/#examples","title":"Examples","text":"NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVEConsider the following complete example:
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing nlohmann::json;\n\nclass A\n{\n private:\n double Aa = 0.0;\n double Ab = 0.0;\n\n public:\n A() = default;\n A(double a, double b) : Aa(a), Ab(b) {}\n NLOHMANN_DEFINE_TYPE_INTRUSIVE(A, Aa, Ab)\n};\n\nclass B : public A\n{\n private:\n int Ba = 0;\n int Bb = 0;\n\n public:\n B() = default;\n B(int a, int b, double aa, double ab) : A(aa, ab), Ba(a), Bb(b) {}\n NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(B, A, Ba, Bb)\n};\n\nint main()\n{\n B example(23, 42, 3.142, 1.777);\n json example_json = example;\n\n std::cout << std::setw(4) << example_json << std::endl;\n}\nOutput:
{\n \"Aa\": 3.142,\n \"Ab\": 1.777,\n \"Ba\": 23,\n \"Bb\": 42\n}\nNotes:
A and B are default-constructible. This is a requirement for using the macro.A has private members and is not a derived class. Hence, macro NLOHMANN_DEFINE_TYPE_INTRUSIVE is used.B is a derived class, NLOHMANN_DEFINE_TYPE_INTRUSIVE is not applicable, but NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE must be used.NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE is used inside the class use as NLOHMANN_DEFINE_TYPE_INTRUSIVE.#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(type, member...) // (1)\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(type, member...) // (2)\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(type, member...) // (3)\nThese macros can be used to simplify the serialization/deserialization of types if you want to use a JSON object as serialization and want to use the member variable names as object keys in that object. The macro is to be defined inside the class/struct to create code for. Unlike NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, it can access private members. The first parameter is the name of the class/struct, and all remaining parameters name the members.
at during deserialization and will throw out_of_range.403 if a key is missing in the JSON object.value during deserialization and fall back to the default value for the respective type of the member variable if a key in the JSON object is missing. The generated from_json() function default constructs an object and uses its values as the defaults when calling the value function.Summary:
Need access to private members Need only serialization Allow missing values when de-serializing macro NLOHMANN_DEFINE_TYPE_INTRUSIVE NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE"},{"location":"api/macros/nlohmann_define_type_intrusive/#parameters","title":"Parameters","text":"type (in) name of the type (class, struct) to serialize/deserialize member (in) name of the member variable to serialize/deserialize; up to 63 members can be given as a comma-separated list"},{"location":"api/macros/nlohmann_define_type_intrusive/#default-definition","title":"Default definition","text":"The macros add two friend functions to the class which take care of the serialization and deserialization:
template<typename BasicJsonType>\nfriend void to_json(BasicJsonType&, const type&);\ntemplate<typename BasicJsonType>\nfriend void from_json(const BasicJsonType&, type&); // except (3)\nSee the examples below for the concrete generated code.
"},{"location":"api/macros/nlohmann_define_type_intrusive/#notes","title":"Notes","text":"Prerequisites
type must be default constructible (except (3)). See How can I use get() for non-default constructible/non-copyable types? for how to overcome this limitation.Implementation limits
to_json/from_json functions manually.Consider the following complete example:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nclass person\n{\n private:\n std::string name = \"John Doe\";\n std::string address = \"123 Fake St\";\n int age = -1;\n\n public:\n person() = default;\n person(std::string name_, std::string address_, int age_)\n : name(std::move(name_)), address(std::move(address_)), age(age_)\n {}\n\n NLOHMANN_DEFINE_TYPE_INTRUSIVE(person, name, address, age)\n};\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"address\": \"742 Evergreen Terrace\", \"age\": 40, \"name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"address\": \"742 Evergreen Terrace\", \"name\": \"Maggie Simpson\"})\"_json;\n try\n {\n auto p3 = j3.get<ns::person>();\n }\n catch (const json::exception& e)\n {\n std::cout << \"deserialization failed: \" << e.what() << std::endl;\n }\n}\nOutput:
serialization: {\"address\":\"744 Evergreen Terrace\",\"age\":60,\"name\":\"Ned Flanders\"}\ndeserialization failed: [json.exception.out_of_range.403] key 'age' not found\nNotes:
ns::person is default-constructible. This is a requirement for using the macro.ns::person has private member variables. This makes NLOHMANN_DEFINE_TYPE_INTRUSIVE applicable, but not NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE.NLOHMANN_DEFINE_TYPE_INTRUSIVE is used inside the class.NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT can be used.The macro is equivalent to:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nclass person\n{\n private:\n std::string name = \"John Doe\";\n std::string address = \"123 Fake St\";\n int age = -1;\n\n public:\n person() = default;\n person(std::string name_, std::string address_, int age_)\n : name(std::move(name_)), address(std::move(address_)), age(age_)\n {}\n\n template<typename BasicJsonType>\n friend void to_json(BasicJsonType& nlohmann_json_j, const person& nlohmann_json_t)\n {\n nlohmann_json_j[\"name\"] = nlohmann_json_t.name;\n nlohmann_json_j[\"address\"] = nlohmann_json_t.address;\n nlohmann_json_j[\"age\"] = nlohmann_json_t.age;\n }\n\n template<typename BasicJsonType>\n friend void from_json(const BasicJsonType& nlohmann_json_j, person& nlohmann_json_t)\n {\n nlohmann_json_t.name = nlohmann_json_j.at(\"name\");\n nlohmann_json_t.address = nlohmann_json_j.at(\"address\");\n nlohmann_json_t.age = nlohmann_json_j.at(\"age\");\n }\n};\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"address\": \"742 Evergreen Terrace\", \"age\": 40, \"name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"address\": \"742 Evergreen Terrace\", \"name\": \"Maggie Simpson\"})\"_json;\n try\n {\n auto p3 = j3.get<ns::person>();\n }\n catch (const json::exception& e)\n {\n std::cout << \"deserialization failed: \" << e.what() << std::endl;\n }\n}\nConsider the following complete example:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nclass person\n{\n private:\n std::string name = \"John Doe\";\n std::string address = \"123 Fake St\";\n int age = -1;\n\n public:\n person() = default;\n person(std::string name_, std::string address_, int age_)\n : name(std::move(name_)), address(std::move(address_)), age(age_)\n {}\n\n NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(person, name, address, age)\n};\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"address\": \"742 Evergreen Terrace\", \"age\": 40, \"name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"address\": \"742 Evergreen Terrace\", \"name\": \"Maggie Simpson\"})\"_json;\n auto p3 = j3.get<ns::person>();\n std::cout << \"roundtrip: \" << json(p3) << std::endl;\n}\nOutput:
serialization: {\"address\":\"744 Evergreen Terrace\",\"age\":60,\"name\":\"Ned Flanders\"}\nroundtrip: {\"address\":\"742 Evergreen Terrace\",\"age\":-1,\"name\":\"Maggie Simpson\"}\nNotes:
ns::person is default-constructible. This is a requirement for using the macro.ns::person has private member variables. This makes NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT applicable, but not NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT.NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT is used inside the class.-1 is used.The macro is equivalent to:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nclass person\n{\n private:\n std::string name = \"John Doe\";\n std::string address = \"123 Fake St\";\n int age = -1;\n\n public:\n person() = default;\n person(std::string name_, std::string address_, int age_)\n : name(std::move(name_)), address(std::move(address_)), age(age_)\n {}\n\n template<typename BasicJsonType>\n friend void to_json(BasicJsonType& nlohmann_json_j, const person& nlohmann_json_t)\n {\n nlohmann_json_j[\"name\"] = nlohmann_json_t.name;\n nlohmann_json_j[\"address\"] = nlohmann_json_t.address;\n nlohmann_json_j[\"age\"] = nlohmann_json_t.age;\n }\n\n template<typename BasicJsonType>\n friend void from_json(const BasicJsonType& nlohmann_json_j, person& nlohmann_json_t)\n {\n person nlohmann_json_default_obj;\n nlohmann_json_t.name = nlohmann_json_j.value(\"name\", nlohmann_json_default_obj.name);\n nlohmann_json_t.address = nlohmann_json_j.value(\"address\", nlohmann_json_default_obj.address);\n nlohmann_json_t.age = nlohmann_json_j.value(\"age\", nlohmann_json_default_obj.age);\n }\n};\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"address\": \"742 Evergreen Terrace\", \"age\": 40, \"name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"address\": \"742 Evergreen Terrace\", \"name\": \"Maggie Simpson\"})\"_json;\n auto p3 = j3.get<ns::person>();\n std::cout << \"roundtrip: \" << json(p3) << std::endl;\n}\nNote how a default-initialized person object is used in the from_json to fill missing values.
Consider the following complete example:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nclass person\n{\n private:\n std::string name = \"John Doe\";\n std::string address = \"123 Fake St\";\n int age = -1;\n\n public:\n // No default constructor\n person(std::string name_, std::string address_, int age_)\n : name(std::move(name_)), address(std::move(address_)), age(age_)\n {}\n\n NLOHMANN_DEFINE_TYPE_INTRUSIVE(person, name, address, age)\n};\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n}\nOutput:
serialization: {\"address\":\"744 Evergreen Terrace\",\"age\":60,\"name\":\"Ned Flanders\"}\nNotes:
ns::person is non-default-constructible. This allows this macro to be used instead of NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT.ns::person has private member variables. This makes NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE applicable, but not NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE.NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE is used inside the class.The macro is equivalent to:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nclass person\n{\n private:\n std::string name = \"John Doe\";\n std::string address = \"123 Fake St\";\n int age = -1;\n\n public:\n // No default constructor\n person(std::string name_, std::string address_, int age_)\n : name(std::move(name_)), address(std::move(address_)), age(age_)\n {}\n\n template<typename BasicJsonType>\n friend void to_json(BasicJsonType& nlohmann_json_j, const person& nlohmann_json_t)\n {\n nlohmann_json_j[\"name\"] = nlohmann_json_t.name;\n nlohmann_json_j[\"address\"] = nlohmann_json_t.address;\n nlohmann_json_j[\"age\"] = nlohmann_json_t.age;\n }\n};\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n}\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(type, member...) // (1)\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(type, member...) // (2)\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(type, member...) // (3)\nThese macros can be used to simplify the serialization/deserialization of types if you want to use a JSON object as serialization and want to use the member variable names as object keys in that object. The macro is to be defined outside the class/struct to create code for, but inside its namespace. Unlike NLOHMANN_DEFINE_TYPE_INTRUSIVE, it cannot access private members. The first parameter is the name of the class/struct, and all remaining parameters name the members.
at during deserialization and will throw out_of_range.403 if a key is missing in the JSON object.value during deserialization and fall back to the default value for the respective type of the member variable if a key in the JSON object is missing. The generated from_json() function default constructs an object and uses its values as the defaults when calling the value function.Summary:
Need access to private members Need only serialization Allow missing values when de-serializing macro NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE"},{"location":"api/macros/nlohmann_define_type_non_intrusive/#parameters","title":"Parameters","text":"type (in) name of the type (class, struct) to serialize/deserialize member (in) name of the (public) member variable to serialize/deserialize; up to 63 members can be given as a comma-separated list"},{"location":"api/macros/nlohmann_define_type_non_intrusive/#default-definition","title":"Default definition","text":"The macros add two functions to the namespace which take care of the serialization and deserialization:
template<typename BasicJsonType>\nvoid to_json(BasicJsonType&, const type&);\ntemplate<typename BasicJsonType>\nvoid from_json(const BasicJsonType&, type&); // except (3)\nSee the examples below for the concrete generated code.
"},{"location":"api/macros/nlohmann_define_type_non_intrusive/#notes","title":"Notes","text":"Prerequisites
type must be default constructible (except (3). See How can I use get() for non-default constructible/non-copyable types? for how to overcome this limitation.Implementation limits
to_json/from_json functions manually.Consider the following complete example:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nstruct person\n{\n std::string name;\n std::string address;\n int age;\n};\n\nNLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"address\": \"742 Evergreen Terrace\", \"age\": 40, \"name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"address\": \"742 Evergreen Terrace\", \"name\": \"Maggie Simpson\"})\"_json;\n try\n {\n auto p3 = j3.get<ns::person>();\n }\n catch (const json::exception& e)\n {\n std::cout << \"deserialization failed: \" << e.what() << std::endl;\n }\n}\nOutput:
serialization: {\"address\":\"744 Evergreen Terrace\",\"age\":60,\"name\":\"Ned Flanders\"}\ndeserialization failed: [json.exception.out_of_range.403] key 'age' not found\nNotes:
ns::person is default-constructible. This is a requirement for using the macro.ns::person has only public member variables. This makes NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE applicable.NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE is used outside the class, but inside its namespace ns.NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT can be used.The macro is equivalent to:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nstruct person\n{\n std::string name;\n std::string address;\n int age;\n};\n\ntemplate<typename BasicJsonType>\nvoid to_json(BasicJsonType& nlohmann_json_j, const person& nlohmann_json_t)\n{\n nlohmann_json_j[\"name\"] = nlohmann_json_t.name;\n nlohmann_json_j[\"address\"] = nlohmann_json_t.address;\n nlohmann_json_j[\"age\"] = nlohmann_json_t.age;\n}\n\ntemplate<typename BasicJsonType>\nvoid from_json(const BasicJsonType& nlohmann_json_j, person& nlohmann_json_t)\n{\n nlohmann_json_t.name = nlohmann_json_j.at(\"name\");\n nlohmann_json_t.address = nlohmann_json_j.at(\"address\");\n nlohmann_json_t.age = nlohmann_json_j.at(\"age\");\n}\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"address\": \"742 Evergreen Terrace\", \"age\": 40, \"name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"address\": \"742 Evergreen Terrace\", \"name\": \"Maggie Simpson\"})\"_json;\n try\n {\n auto p3 = j3.get<ns::person>();\n }\n catch (const json::exception& e)\n {\n std::cout << \"deserialization failed: \" << e.what() << std::endl;\n }\n}\nConsider the following complete example:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nstruct person\n{\n std::string name = \"John Doe\";\n std::string address = \"123 Fake St\";\n int age = -1;\n\n person() = default;\n person(std::string name_, std::string address_, int age_)\n : name(std::move(name_)), address(std::move(address_)), age(age_)\n {}\n};\n\nNLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(person, name, address, age)\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"address\": \"742 Evergreen Terrace\", \"age\": 40, \"name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"address\": \"742 Evergreen Terrace\", \"name\": \"Maggie Simpson\"})\"_json;\n auto p3 = j3.get<ns::person>();\n std::cout << \"roundtrip: \" << json(p3) << std::endl;\n}\nOutput:
serialization: {\"address\":\"744 Evergreen Terrace\",\"age\":60,\"name\":\"Ned Flanders\"}\nroundtrip: {\"address\":\"742 Evergreen Terrace\",\"age\":-1,\"name\":\"Maggie Simpson\"}\nNotes:
ns::person is default-constructible. This is a requirement for using the macro.ns::person has only public member variables. This makes NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT applicable.NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT is used outside the class, but inside its namespace ns.-1 is used.The macro is equivalent to:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nstruct person\n{\n std::string name = \"John Doe\";\n std::string address = \"123 Fake St\";\n int age = -1;\n\n person() = default;\n person(std::string name_, std::string address_, int age_)\n : name(std::move(name_)), address(std::move(address_)), age(age_)\n {}\n};\n\ntemplate<typename BasicJsonType>\nvoid to_json(BasicJsonType& nlohmann_json_j, const person& nlohmann_json_t)\n{\n nlohmann_json_j[\"name\"] = nlohmann_json_t.name;\n nlohmann_json_j[\"address\"] = nlohmann_json_t.address;\n nlohmann_json_j[\"age\"] = nlohmann_json_t.age;\n}\n\ntemplate<typename BasicJsonType>\nvoid from_json(const BasicJsonType& nlohmann_json_j, person& nlohmann_json_t)\n{\n person nlohmann_json_default_obj;\n nlohmann_json_t.name = nlohmann_json_j.value(\"name\", nlohmann_json_default_obj.name);\n nlohmann_json_t.address = nlohmann_json_j.value(\"address\", nlohmann_json_default_obj.address);\n nlohmann_json_t.age = nlohmann_json_j.value(\"age\", nlohmann_json_default_obj.age);\n}\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"address\": \"742 Evergreen Terrace\", \"age\": 40, \"name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"address\": \"742 Evergreen Terrace\", \"name\": \"Maggie Simpson\"})\"_json;\n auto p3 = j3.get<ns::person>();\n std::cout << \"roundtrip: \" << json(p3) << std::endl;\n}\nNote how a default-initialized person object is used in the from_json to fill missing values.
Consider the following complete example:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nstruct person\n{\n std::string name;\n std::string address;\n int age;\n};\n\nNLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(person, name, address, age)\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n}\nOutput:
serialization: {\"address\":\"744 Evergreen Terrace\",\"age\":60,\"name\":\"Ned Flanders\"}\nNotes:
ns::person is non-default-constructible. This allows this macro to be used instead of NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT.ns::person has only public member variables. This makes NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE applicable.NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE is used outside the class, but inside its namespace ns.The macro is equivalent to:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nstruct person\n{\n std::string name;\n std::string address;\n int age;\n};\n\ntemplate<typename BasicJsonType>\nvoid to_json(BasicJsonType& nlohmann_json_j, const person& nlohmann_json_t)\n{\n nlohmann_json_j[\"name\"] = nlohmann_json_t.name;\n nlohmann_json_j[\"address\"] = nlohmann_json_t.address;\n nlohmann_json_j[\"age\"] = nlohmann_json_t.age;\n}\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n}\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_NAMES(type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES(type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_NAMES(type, base_type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(type, base_type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(type, base_type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_NAMES(type, base_type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(type, base_type, \"json_member_name\", member...)\n#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(type, base_type, \"json_member_name\", member...)\nThese macros can be used in case you want to use the custom names for the member variables in the resulting JSON. They behave exactly as their non-WITH_NAMES counterparts, but require an additional parameter for each member variable which will be used in JSON. Both serialization and deserialization will only use the custom names for JSON, the names of the member variables themselves will be ignored.
Using the named conversion macros will halve the maximum number of member variables from 63 to 31.
For further information please refer to the corresponding macros without WITH_NAMES.
type (in) name of the type (class, struct) to serialize/deserialize base_type (in) name of the base type (class, struct) type is derived from (used only in DEFINE_DERIVED_TYPE macros) json_member_name (in) the string that will be used as the name for the next value member (in) name of the member variable to serialize/deserialize"},{"location":"api/macros/nlohmann_define_type_with_names/#examples","title":"Examples","text":"Example (1): NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES Consider the following complete example:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nstruct person\n{\n std::string name;\n std::string address;\n int age;\n};\n\nNLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES(person, \"json_name\", name, \"json_address\", address, \"json_age\", age)\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"json_address\": \"742 Evergreen Terrace\", \"json_age\": 40, \"json_name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.template get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"json_address\": \"742 Evergreen Terrace\", \"json_name\": \"Maggie Simpson\"})\"_json;\n try\n {\n auto p3 = j3.template get<ns::person>();\n }\n catch (const json::exception& e)\n {\n std::cout << \"deserialization failed: \" << e.what() << std::endl;\n }\n}\nOutput:
serialization: {\"json_address\":\"744 Evergreen Terrace\",\"json_age\":60,\"json_name\":\"Ned Flanders\"}\ndeserialization failed: [json.exception.out_of_range.403] key 'json_age' not found\nNotes:
ns::person is default-constructible. This is a requirement for using the macro.ns::person has only public member variables. This makes NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES applicable.NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES is used outside the class, but inside its namespace ns.NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES can be used.The macro is equivalent to:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nnamespace ns\n{\nstruct person\n{\n std::string name;\n std::string address;\n int age;\n};\n\ntemplate <typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0>\nvoid to_json(BasicJsonType& nlohmann_json_j, const person& nlohmann_json_t)\n{\n nlohmann_json_j[\"json_name\"] = nlohmann_json_t.name;\n nlohmann_json_j[\"json_address\"] = nlohmann_json_t.address;\n nlohmann_json_j[\"json_age\"] = nlohmann_json_t.age;\n}\n\ntemplate <typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0>\nvoid from_json(const BasicJsonType& nlohmann_json_j, person& nlohmann_json_t)\n{\n nlohmann_json_j.at(\"json_name\").get_to(nlohmann_json_t.name);\n nlohmann_json_j.at(\"json_address\").get_to(nlohmann_json_t.address);\n nlohmann_json_j.at(\"json_age\").get_to(nlohmann_json_t.age);\n}\n} // namespace ns\n\nint main()\n{\n ns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n // serialization: person -> json\n json j = p;\n std::cout << \"serialization: \" << j << std::endl;\n\n // deserialization: json -> person\n json j2 = R\"({\"json_address\": \"742 Evergreen Terrace\", \"json_age\": 40, \"json_name\": \"Homer Simpson\"})\"_json;\n auto p2 = j2.template get<ns::person>();\n\n // incomplete deserialization:\n json j3 = R\"({\"json_address\": \"742 Evergreen Terrace\", \"json_name\": \"Maggie Simpson\"})\"_json;\n try\n {\n auto p3 = j3.template get<ns::person>();\n }\n catch (const json::exception& e)\n {\n std::cout << \"deserialization failed: \" << e.what() << std::endl;\n }\n}\n#define NLOHMANN_JSON_NAMESPACE /* value */\nThis macro evaluates to the full name of the nlohmann namespace.
The default value consists of the root namespace (nlohmann) and an inline ABI namespace. See nlohmann Namespace for details.
When the macro is not defined, the library will define it to its default value. Overriding this value has no effect on the library.
"},{"location":"api/macros/nlohmann_json_namespace/#examples","title":"Examples","text":"ExampleThe example shows how to use NLOHMANN_JSON_NAMESPACE instead of just nlohmann, as well as how to output the value of NLOHMANN_JSON_NAMESPACE.
#include <iostream>\n#include <nlohmann/json.hpp>\n\n// possible use case: use NLOHMANN_JSON_NAMESPACE instead of nlohmann\nusing json = NLOHMANN_JSON_NAMESPACE::json;\n\n// macro needed to output the NLOHMANN_JSON_NAMESPACE as string literal\n#define Q(x) #x\n#define QUOTE(x) Q(x)\n\nint main()\n{\n std::cout << QUOTE(NLOHMANN_JSON_NAMESPACE) << std::endl;\n}\nOutput:
nlohmann::json_abi_v3_12_0\nNLOHMANN_JSON_NAMESPACE_BEGIN, NLOHMANN_JSON_NAMESPACE_ENDNLOHMANN_JSON_NAMESPACE_NO_VERSION#define NLOHMANN_JSON_NAMESPACE_BEGIN /* value */ // (1)\n#define NLOHMANN_JSON_NAMESPACE_END /* value */ // (2)\nThese macros can be used to open and close the nlohmann namespace. See nlohmann Namespace for details.
The default definitions open and close the nlohmann namespace. The precise definition of [NLOHMANN_JSON_NAMESPACE_BEGIN] varies as described here.
Default definition of NLOHMANN_JSON_NAMESPACE_BEGIN:
namespace nlohmann\n{\ninline namespace json_abi_v3_12_0\n{\nDefault definition of NLOHMANN_JSON_NAMESPACE_END:
} // namespace json_abi_v3_12_0\n} // namespace nlohmann\nWhen these macros are not defined, the library will define them to their default definitions.
"},{"location":"api/macros/nlohmann_json_namespace_begin/#examples","title":"Examples","text":"ExampleThe example shows how to use NLOHMANN_JSON_NAMESPACE_BEGIN/NLOHMANN_JSON_NAMESPACE_END from the How do I convert third-party types? page.
#include <iostream>\n#include <optional>\n#include <nlohmann/json.hpp>\n\n// partial specialization (see https://json.nlohmann.me/features/arbitrary_types/)\nNLOHMANN_JSON_NAMESPACE_BEGIN\ntemplate <typename T>\nstruct adl_serializer<std::optional<T>>\n{\n static void to_json(json& j, const std::optional<T>& opt)\n {\n if (opt == std::nullopt)\n {\n j = nullptr;\n }\n else\n {\n j = *opt;\n }\n }\n};\nNLOHMANN_JSON_NAMESPACE_END\n\nint main()\n{\n std::optional<int> o1 = 1;\n std::optional<int> o2 = std::nullopt;\n\n NLOHMANN_JSON_NAMESPACE::json j;\n j.push_back(o1);\n j.push_back(o2);\n std::cout << j << std::endl;\n}\nOutput:
[1,null]\nnlohmann NamespaceNLOHMANN_JSON_NAMESPACE_NO_VERSION#define NLOHMANN_JSON_NAMESPACE_NO_VERSION /* value */\nIf defined to 1, the version component is omitted from the inline namespace. See nlohmann Namespace for details.
The default value is 0.
#define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0\nWhen the macro is not defined, the library will define it to its default value.
"},{"location":"api/macros/nlohmann_json_namespace_no_version/#examples","title":"Examples","text":"ExampleThe example shows how to use NLOHMANN_JSON_NAMESPACE_NO_VERSION to disable the version component of the inline namespace.
#include <iostream>\n\n#define NLOHMANN_JSON_NAMESPACE_NO_VERSION 1\n#include <nlohmann/json.hpp>\n\n// macro needed to output the NLOHMANN_JSON_NAMESPACE as string literal\n#define Q(x) #x\n#define QUOTE(x) Q(x)\n\nint main()\n{\n std::cout << QUOTE(NLOHMANN_JSON_NAMESPACE) << std::endl;\n}\nOutput:
nlohmann::json_abi\nnlohmann NamespaceNLOHMANN_JSON_NAMESPACENLOHMANN_JSON_NAMESPACE_BEGIN, NLOHMANN_JSON_NAMESPACE_END#define NLOHMANN_JSON_SERIALIZE_ENUM(type, conversion...)\nBy default, enum values are serialized to JSON as integers. In some cases, this could result in undesired behavior. If an enum is modified or re-ordered after data has been serialized to JSON, the later deserialized JSON data may be undefined or a different enum value than was originally intended.
The NLOHMANN_JSON_SERIALIZE_ENUM allows to define a user-defined serialization for every enumerator.
type (in) name of the enum to serialize/deserialize conversion (in) a pair of an enumerator and a JSON serialization; arbitrary pairs can be given as a comma-separated list"},{"location":"api/macros/nlohmann_json_serialize_enum/#default-definition","title":"Default definition","text":"The macro adds two functions to the namespace which take care of the serialization and deserialization:
template<typename BasicJsonType>\ninline void to_json(BasicJsonType& j, const type& e);\ntemplate<typename BasicJsonType>\ninline void from_json(const BasicJsonType& j, type& e);\nPrerequisites
The macro must be used inside the namespace of the enum.
Important notes
get<ENUM_TYPE>(), undefined JSON values will default to the first specified conversion. Select this default pair carefully. See example 1 below.The example shows how NLOHMANN_JSON_SERIALIZE_ENUM can be used to serialize/deserialize both classical enums and C++11 enum classes:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\nenum TaskState\n{\n TS_STOPPED,\n TS_RUNNING,\n TS_COMPLETED,\n TS_INVALID = -1\n};\n\nNLOHMANN_JSON_SERIALIZE_ENUM(TaskState,\n{\n { TS_INVALID, nullptr },\n { TS_STOPPED, \"stopped\" },\n { TS_RUNNING, \"running\" },\n { TS_COMPLETED, \"completed\" }\n})\n\nenum class Color\n{\n red, green, blue, unknown\n};\n\nNLOHMANN_JSON_SERIALIZE_ENUM(Color,\n{\n { Color::unknown, \"unknown\" }, { Color::red, \"red\" },\n { Color::green, \"green\" }, { Color::blue, \"blue\" }\n})\n} // namespace ns\n\nint main()\n{\n // serialization\n json j_stopped = ns::TS_STOPPED;\n json j_red = ns::Color::red;\n std::cout << \"ns::TS_STOPPED -> \" << j_stopped\n << \", ns::Color::red -> \" << j_red << std::endl;\n\n // deserialization\n json j_running = \"running\";\n json j_blue = \"blue\";\n auto running = j_running.get<ns::TaskState>();\n auto blue = j_blue.get<ns::Color>();\n std::cout << j_running << \" -> \" << running\n << \", \" << j_blue << \" -> \" << static_cast<int>(blue) << std::endl;\n\n // deserializing undefined JSON value to enum\n // (where the first map entry above is the default)\n json j_pi = 3.14;\n auto invalid = j_pi.get<ns::TaskState>();\n auto unknown = j_pi.get<ns::Color>();\n std::cout << j_pi << \" -> \" << invalid << \", \"\n << j_pi << \" -> \" << static_cast<int>(unknown) << std::endl;\n}\nOutput:
ns::TS_STOPPED -> \"stopped\", ns::Color::red -> \"red\"\n\"running\" -> 1, \"blue\" -> 2\n3.14 -> -1, 3.14 -> 3\nThe example shows how to use multiple conversions for a single enumerator. In the example, Color::red will always be serialized to \"red\", because the first occurring conversion. The second conversion, however, offers an alternative deserialization from \"rot\" to Color::red.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\nenum class Color\n{\n red, green, blue, unknown\n};\n\nNLOHMANN_JSON_SERIALIZE_ENUM(Color,\n{\n { Color::unknown, \"unknown\" }, { Color::red, \"red\" },\n { Color::green, \"green\" }, { Color::blue, \"blue\" },\n { Color::red, \"rot\" } // a second conversion for Color::red\n})\n}\n\nint main()\n{\n // serialization\n json j_red = ns::Color::red;\n std::cout << static_cast<int>(ns::Color::red) << \" -> \" << j_red << std::endl;\n\n // deserialization\n json j_rot = \"rot\";\n auto rot = j_rot.get<ns::Color>();\n auto red = j_red.get<ns::Color>();\n std::cout << j_rot << \" -> \" << static_cast<int>(rot) << std::endl;\n std::cout << j_red << \" -> \" << static_cast<int>(red) << std::endl;\n}\nOutput:
0 -> \"red\"\n\"rot\" -> 0\n\"red\" -> 0\nNLOHMANN_JSON_SERIALIZE_ENUM_STRICTJSON_DISABLE_ENUM_SERIALIZATIONAdded in version 3.4.0.
"},{"location":"api/macros/nlohmann_json_serialize_enum_strict/","title":"NLOHMANN_JSON_SERIALIZE_ENUM_STRICT","text":"#define NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(type, conversion...)\nBy default, enum values are serialized to JSON as integers. In some cases, this could result in undesired behavior. If an enum is modified or re-ordered after data has been serialized to JSON, the later deserialized JSON data may be undefined or a different enum value than was originally intended.
NLOHMANN_JSON_SERIALIZE_ENUM_STRICT allows to define a user-defined serialization for every enumerator that throws an exception on undefined input.
type (in) name of the enum to serialize/deserialize conversion (in) a pair of an enumerator and a JSON serialization; arbitrary pairs can be given as a comma-separated list"},{"location":"api/macros/nlohmann_json_serialize_enum_strict/#default-definition","title":"Default definition","text":"The macro adds two functions to the namespace which take care of the serialization and deserialization:
template<typename BasicJsonType>\ninline void to_json(BasicJsonType& j, const type& e);\ntemplate<typename BasicJsonType>\ninline void from_json(const BasicJsonType& j, type& e);\nPrerequisites
The macro must be used inside the namespace of the enum.
Important notes
out_of_range.410 in both directions: when serializing an enum value not listed in the conversions, and when deserializing (e.g., via get<ENUM_TYPE>()) a JSON value that matches no conversion; example: \"enum value out of range for <type>\".The example shows how NLOHMANN_JSON_SERIALIZE_ENUM_STRICT can be used to serialize/deserialize both classical enums and C++11 enum classes:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\nenum TaskState\n{\n TS_STOPPED,\n TS_RUNNING,\n TS_COMPLETED,\n TS_INVALID = -1\n};\n\nNLOHMANN_JSON_SERIALIZE_ENUM_STRICT(TaskState,\n{\n { TS_INVALID, nullptr },\n { TS_STOPPED, \"stopped\" },\n { TS_RUNNING, \"running\" },\n { TS_COMPLETED, \"completed\" }\n})\n\nenum class Color\n{\n red, green, blue, unknown\n};\n\nNLOHMANN_JSON_SERIALIZE_ENUM_STRICT(Color,\n{\n { Color::unknown, \"unknown\" }, { Color::red, \"red\" },\n { Color::green, \"green\" }, { Color::blue, \"blue\" }\n})\n} // namespace ns\n\nint main()\n{\n // serialization\n json j_stopped = ns::TS_STOPPED;\n json j_red = ns::Color::red;\n std::cout << \"ns::TS_STOPPED -> \" << j_stopped\n << \", ns::Color::red -> \" << j_red << std::endl;\n\n // deserialization\n json j_running = \"running\";\n json j_blue = \"blue\";\n auto running = j_running.get<ns::TaskState>();\n auto blue = j_blue.get<ns::Color>();\n std::cout << j_running << \" -> \" << running\n << \", \" << j_blue << \" -> \" << static_cast<int>(blue) << std::endl;\n\n}\nOutput:
ns::TS_STOPPED -> \"stopped\", ns::Color::red -> \"red\"\n\"running\" -> 1, \"blue\" -> 2\nThe example shows how to use multiple conversions for a single enumerator. In the example, Color::red will always be serialized to \"red\", because the first occurring conversion. The second conversion, however, offers an alternative deserialization from \"rot\" to Color::red.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\nenum class Color\n{\n red, green, blue, unknown\n};\n\nNLOHMANN_JSON_SERIALIZE_ENUM_STRICT(Color,\n{\n { Color::unknown, \"unknown\" }, { Color::red, \"red\" },\n { Color::green, \"green\" }, { Color::blue, \"blue\" },\n { Color::red, \"rot\" } // a second conversion for Color::red\n})\n}\n\nint main()\n{\n // serialization\n json j_red = ns::Color::red;\n std::cout << static_cast<int>(ns::Color::red) << \" -> \" << j_red << std::endl;\n\n // deserialization\n json j_rot = \"rot\";\n auto rot = j_rot.get<ns::Color>();\n auto red = j_red.get<ns::Color>();\n std::cout << j_rot << \" -> \" << static_cast<int>(rot) << std::endl;\n std::cout << j_red << \" -> \" << static_cast<int>(red) << std::endl;\n}\nOutput:
0 -> \"red\"\n\"rot\" -> 0\n\"red\" -> 0\nThe example shows how an invalid serialization causes an exception to be thrown. In the example, Color::unknown is not defined in the mapping used to call NLOHMANN_JSON_SERIALIZE_ENUM_STRICT so causes an exception when used to serialize. Similarly, \"what\" does not refer to an enum value so also causes an exception when deserialization is attempted.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nnamespace ns\n{\n\nenum class Color\n{\n red,\n green,\n blue,\n unknown // not mapped in JSON_SERIALIZE_ENUM_STRICT\n};\n\nNLOHMANN_JSON_SERIALIZE_ENUM_STRICT(Color,\n{\n {Color::red, \"red\"},\n {Color::green, \"green\"},\n {Color::blue, \"blue\"}\n})\n\n} // namespace ns\n\n\nint main()\n{\n // invalid serialization\n try\n {\n // ns::color::unknown was not mapped in macro\n json invalid_serialization = ns::Color::unknown;\n }\n catch (const json::exception e)\n {\n std::cout << \"deserialization failed: \" << e.what() << std::endl;\n }\n\n // invalid deserialization\n try\n {\n // what does not map to an enum\n json invalid_deserialization(\"what\");\n ns::Color color = invalid_deserialization.get<ns::Color>();\n }\n catch (const json::exception e)\n {\n std::cout << \"deserialization failed: \" << e.what() << std::endl;\n }\n\n return 0;\n}\nOutput:
deserialization failed: [json.exception.out_of_range.410] enum value out of range for Color\ndeserialization failed: [json.exception.out_of_range.410] enum value out of range for Color: \"what\"\nNLOHMANN_JSON_SERIALIZE_ENUMJSON_DISABLE_ENUM_SERIALIZATIONAdded in version 3.12.x.
"},{"location":"api/macros/nlohmann_json_version_major/","title":"NLOHMANN_JSON_VERSION_MAJOR, NLOHMANN_JSON_VERSION_MINOR, NLOHMANN_JSON_VERSION_PATCH","text":"#define NLOHMANN_JSON_VERSION_MAJOR /* value */\n#define NLOHMANN_JSON_VERSION_MINOR /* value */\n#define NLOHMANN_JSON_VERSION_PATCH /* value */\nThese macros are defined by the library and contain the version numbers according to Semantic Versioning 2.0.0.
"},{"location":"api/macros/nlohmann_json_version_major/#default-definition","title":"Default definition","text":"The macros are defined according to the current library version.
"},{"location":"api/macros/nlohmann_json_version_major/#examples","title":"Examples","text":"ExampleThe example below shows how NLOHMANN_JSON_VERSION_MAJOR, NLOHMANN_JSON_VERSION_MINOR, and NLOHMANN_JSON_VERSION_PATCH are defined by the library.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << \"JSON for Modern C++ version \"\n << NLOHMANN_JSON_VERSION_MAJOR << \".\"\n << NLOHMANN_JSON_VERSION_MINOR << \".\"\n << NLOHMANN_JSON_VERSION_PATCH << std::endl;\n}\nOutput:
JSON for Modern C++ version 3.12.0\nWe as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
"},{"location":"community/code_of_conduct/#our-standards","title":"Our Standards","text":"Examples of behavior that contributes to a positive environment for our community include:
Examples of unacceptable behavior include:
Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
"},{"location":"community/code_of_conduct/#scope","title":"Scope","text":"This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official email address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
"},{"location":"community/code_of_conduct/#enforcement","title":"Enforcement","text":"Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at mail@nlohmann.me. All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the reporter of any incident.
"},{"location":"community/code_of_conduct/#enforcement-guidelines","title":"Enforcement Guidelines","text":"Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
"},{"location":"community/code_of_conduct/#1-correction","title":"1. Correction","text":"Community Impact: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
Consequence: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
"},{"location":"community/code_of_conduct/#2-warning","title":"2. Warning","text":"Community Impact: A violation through a single incident or series of actions.
Consequence: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
"},{"location":"community/code_of_conduct/#3-temporary-ban","title":"3. Temporary Ban","text":"Community Impact: A serious violation of community standards, including sustained inappropriate behavior.
Consequence: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
"},{"location":"community/code_of_conduct/#4-permanent-ban","title":"4. Permanent Ban","text":"Community Impact: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
Consequence: A permanent ban from any sort of public interaction within the community.
"},{"location":"community/code_of_conduct/#attribution","title":"Attribution","text":"This Code of Conduct is adapted from the Contributor Covenant, version 2.1, available at https://www.contributor-covenant.org/version/2/1/code_of_conduct.html.
Community Impact Guidelines were inspired by Mozilla's code of conduct enforcement ladder.
For answers to common questions about this code of conduct, see the FAQ at https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.
"},{"location":"community/contribution_guidelines/","title":"Contribution Guidelines","text":"Thank you for your interest in contributing to this project! What began as an exercise to explore the exciting features of C++11 has evolved into a widely used JSON library. I truly appreciate all the contributions from the community, whether it's proposing features, identifying bugs, or fixing mistakes! To ensure that our collaboration is efficient and effective, please follow these guidelines.
Feel free to discuss or suggest improvements to this document by submitting a pull request.
"},{"location":"community/contribution_guidelines/#ways-to-contribute","title":"Ways to Contribute","text":"There are multiple ways to contribute.
"},{"location":"community/contribution_guidelines/#reporting-an-issue","title":"Reporting an issue","text":"Please create an issue, assuming one does not already exist, and describe your concern. Note you need a GitHub account for this.
Clearly describe the issue:
Please stick to the provided issue template bug report if possible.
"},{"location":"community/contribution_guidelines/#reporting-a-security-vulnerability","title":"Reporting a security vulnerability","text":"You can report a security vulnerability according to our security policy.
"},{"location":"community/contribution_guidelines/#discussing-a-new-feature","title":"Discussing a new feature","text":"For questions, feature or support requests, please open a discussion. If you find a proposed answer satisfactory, please use the \"Mark as answer\" button to make it easier for readers to see what helped and for the community to filter for open questions.
"},{"location":"community/contribution_guidelines/#proposing-a-fix-or-an-improvement","title":"Proposing a fix or an improvement","text":"Join an ongoing discussion or comment on an existing issue before starting to code. This can help to avoid duplicate efforts or other frustration during the later review.
Create a pull request against the develop branch and follow the pull request template. In particular,
We describe all points in detail below.
All contributions (including pull requests) must agree to the Developer Certificate of Origin (DCO) version 1.1. This is exactly the same one created and used by the Linux kernel developers and posted on http://developercertificate.org/. This is a developer's certification that he or she has the right to submit the patch for inclusion into the project.
"},{"location":"community/contribution_guidelines/#how-to","title":"How to...","text":""},{"location":"community/contribution_guidelines/#describe-your-changes","title":"Describe your changes","text":"This library is primarily maintained as a spare-time project. As such, I cannot make any guarantee how quickly changes are merged and released. Therefore, it is very important to make the review as smooth as possible by explaining not only what you changed, but why. This rationale can be very valuable down the road when improvements or bugs are discussed years later.
"},{"location":"community/contribution_guidelines/#reference-an-existing-issue","title":"Reference an existing issue","text":"Link a pull request to an issue to clarify that a fix is forthcoming and which issue can be closed after merging. Only a few cases (e.g., fixing typos) do not require prior discussions.
"},{"location":"community/contribution_guidelines/#write-tests","title":"Write tests","text":"The library has an extensive test suite that currently covers 100 % of the library's code. These tests are crucial to maintain API stability and give future contributors confidence that they do not accidentally break things. As Titus Winters aptly put it:
If you liked it, you should have put a test on it.
"},{"location":"community/contribution_guidelines/#run-the-tests","title":"Run the tests","text":"First, ensure the test suite runs before making any changes:
$ cmake -S. -B build\n$ cmake --build build -j 10\n$ ctest --test-dir build -j 10\nThe test suite should report:
100% tests passed, 0 tests failed out of 98\nThe tests are located in tests/src/unit-*.cpp and contain doctest assertions like CHECK. The tests are structured along the features of the library or the nature of the tests. Usually, it should be clear from the context which existing file needs to be extended, and only very few cases require creating new test files.
When fixing a bug, edit unit-regression2.cpp and add a section referencing the fixed issue.
When you test exceptions, please use CHECK_THROWS_WITH_AS which also takes the what() argument of the thrown exception into account.
If test coverage decreases, an automatic warning comment will be posted on the pull request. You can access a code coverage report as an artifact to the \u201cUbuntu\u201d workflow.
"},{"location":"community/contribution_guidelines/#update-the-documentation","title":"Update the documentation","text":"The main documentation of the library is generated from the files docs/mkdocs/docs. This folder contains dedicated pages for certain features, a list of all exceptions, and extensive API documentation with details on every public API function.
Build the documentation locally using:
make install_venv -C docs/mkdocs\nmake serve -C docs/mkdocs\nThe documentation will then be available at http://127.0.0.1:8000/. See the documentation of mkdocs and Material for MkDocs for more information.
"},{"location":"community/contribution_guidelines/#amalgamate-the-source-code","title":"Amalgamate the source code","text":"The single-header files single_include/nlohmann/json.hpp and single_include/nlohmann/json_fwd.hpp are generated from the source files in the include/nlohmann directory. Do not edit the files directly; instead, modify the include/nlohmann sources and regenerate the files by executing:
make amalgamate\nRunning make amalgamate will also apply automatic formatting to the source files using Artistic Style. This formatting may modify your source files in-place. Be certain to review and commit any changes to avoid unintended formatting diffs in commits.
Certain contributions are not helpful.
"},{"location":"community/contribution_guidelines/#break-the-public-api","title":"Break the public API","text":"We take pride in the library being used by numerous customers across various industries. They all rely on the guarantees provided by semantic versioning. Please do not change the library such that the public API of the 3.x.y version is broken. This includes:
Although these guidelines may seem restrictive, they are essential for maintaining the library\u2019s utility.
Breaking changes may be introduced when they are guarded with a feature macro such as JSON_USE_IMPLICIT_CONVERSIONS which allows selectively changing the behavior of the library. In next steps, the current behavior can then be deprecated. Using feature macros then allows users to test their code against the library in the next major release.
This library is designed to work with C++11 and later. This means that any supported C++11 compiler should compile the library without problems. Some compilers like GCC 4.7 (and earlier), Clang 3.3 (and earlier), or Microsoft Visual Studio 13.0 and earlier are known not to work due to missing or incomplete C++11 support.
Please do not add features that do not work with the mentioned supported compilers. Please guard features from C++14 and later against the respective JSON_HAS_CPP_14 macros.
Please refrain from proposing changes that would break JSON conformance. If you propose a conformant extension of JSON to be supported by the library, please motivate this extension.
"},{"location":"community/contribution_guidelines/#wanted","title":"Wanted","text":"The following areas really need contribution and are always welcomed:
json.hpp header, and I am not aware of approaches similar to re2c for parsing.We look forward to your contributions and collaboration to enhance the library!
"},{"location":"community/governance/","title":"Governance","text":"The governance model for the JSON for Modern C++ project is a Benevolent Dictator for Life (BDFL) structure. As the sole maintainer, Niels Lohmann is responsible for all key aspects of the project. The project governance may evolve as the project grows, but any changes will be documented here and communicated to contributors.
"},{"location":"community/governance/#overview","title":"Overview","text":"This project is led by a benevolent dictator, Niels Lohmann, and managed by the community. That is, the community actively contributes to the day-to-day maintenance of the project, but the general strategic line is drawn by the benevolent dictator. In case of disagreement, they have the last word. It is the benevolent dictator\u2019s job to resolve disputes within the community and to ensure that the project is able to progress in a coordinated way. In turn, it is the community\u2019s job to guide the decisions of the benevolent dictator through active engagement and contribution.
"},{"location":"community/governance/#roles-and-responsibilities","title":"Roles and responsibilities","text":""},{"location":"community/governance/#benevolent-dictator-project-lead","title":"Benevolent dictator (project lead)","text":"Typically, the benevolent dictator, or project lead, is self-appointed. However, because the community always has the ability to fork, this person is fully answerable to the community. The project lead\u2019s role is a difficult one: they set the strategic objectives of the project and communicate these clearly to the community. They also have to understand the community as a whole and strive to satisfy as many conflicting needs as possible, while ensuring that the project survives in the long term.
In many ways, the role of the benevolent dictator is less about dictatorship and more about diplomacy. The key is to ensure that, as the project expands, the right people are given influence over it and the community rallies behind the vision of the project lead. The lead\u2019s job is then to ensure that the committers (see below) make the right decisions on behalf of the project. Generally speaking, as long as the committers are aligned with the project\u2019s strategy, the project lead will allow them to proceed as they desire.
"},{"location":"community/governance/#committers","title":"Committers","text":"Committers are contributors who have made several valuable contributions to the project and are now relied upon to both write code directly to the repository and screen the contributions of others. In many cases they are programmers but it is also possible that they contribute in a different role. Typically, a committer will focus on a specific aspect of the project, and will bring a level of expertise and understanding that earns them the respect of the community and the project lead. The role of committer is not an official one, it is simply a position that influential members of the community will find themselves in as the project lead looks to them for guidance and support.
Committers have no authority over the overall direction of the project. However, they do have the ear of the project lead. It is a committer\u2019s job to ensure that the lead is aware of the community\u2019s needs and collective objectives, and to help develop or elicit appropriate contributions to the project. Often, committers are given informal control over their specific areas of responsibility, and are assigned rights to directly modify certain areas of the source code. That is, although committers do not have explicit decision-making authority, they will often find that their actions are synonymous with the decisions made by the lead.
"},{"location":"community/governance/#contributors","title":"Contributors","text":"Contributors are community members who either have no desire to become committers, or have not yet been given the opportunity by the benevolent dictator. They make valuable contributions, such as those outlined in the list below, but generally do not have the authority to make direct changes to the project code. Contributors engage with the project through communication tools, such as email lists, and via reports and patches attached to issues in the issue tracker, as detailed in our community tools document.
Anyone can become a contributor. There is no expectation of commitment to the project, no specific skill requirements and no selection process. To become a contributor, a community member simply has to perform one or more actions that are beneficial to the project.
Some contributors will already be engaging with the project as users, but will also find themselves doing one or more of the following:
As contributors gain experience and familiarity with the project, they may find that the project lead starts relying on them more and more. When this begins to happen, they gradually adopt the role of committer, as described above.
"},{"location":"community/governance/#users","title":"Users","text":"Users are community members who have a need for the project. They are the most important members of the community: without them, the project would have no purpose. Anyone can be a user; there are no specific requirements.
Users should be encouraged to participate in the life of the project and the community as much as possible. User contributions enable the project team to ensure that they are satisfying the needs of those users. Common user activities include (but are not limited to):
Users who continue to engage with the project and its community will often find themselves becoming more and more involved. Such users may then go on to become contributors, as described above.
"},{"location":"community/governance/#support","title":"Support","text":"All participants in the community are encouraged to provide support for new users within the project management infrastructure. This support is provided as a way of growing the community. Those seeking support should recognise that all support activity within the project is voluntary and is therefore provided as and when time allows. A user requiring guaranteed response times or results should therefore seek to purchase a support contract from a vendor. (Of course, that vendor should be an active member of the community.) However, for those willing to engage with the project on its own terms, and willing to help support other users, the community support channels are ideal.
"},{"location":"community/governance/#contribution-process","title":"Contribution Process","text":"Anyone can contribute to the project, regardless of their skills, as there are many ways to contribute. For instance, a contributor might be active on the project mailing list and issue tracker, or might supply patches. The various ways of contributing are described in more detail in our roles in open source document.
The developer mailing list is the most appropriate place for a contributor to ask for help when making their first contribution.
"},{"location":"community/governance/#decision-making-process","title":"Decision-Making Process","text":"The benevolent dictatorship model does not need a formal conflict resolution process, since the project lead\u2019s word is final. If the community chooses to question the wisdom of the actions of a committer, the project lead can review their decisions by checking the email archives, and either uphold or reverse them.
Source
The text was taken from http://oss-watch.ac.uk/resources/benevolentdictatorgovernancemodel.
"},{"location":"community/quality_assurance/","title":"Quality assurance","text":"Ensuring quality is paramount for this project, particularly because numerous other projects depend on it. Each commit to the library undergoes rigorous checks against the following requirements, and any violations will result in a failed build.
"},{"location":"community/quality_assurance/#c-language-compliance-and-compiler-compatibility","title":"C++ language compliance and compiler compatibility","text":"Requirement: Compiler support
Any compiler with complete C++11 support can compile the library without warnings.
The library is compiled with 50+ different C++ compilers with different operating systems and platforms, including the oldest versions known to compile the library.
Compilers used in continuous integration Compiler Architecture Operating System CI AppleClang 15.0.0.15000040; Xcode 15.0.1 arm64 macOS 14.7.2 (Sonoma) GitHub AppleClang 15.0.0.15000100; Xcode 15.1 arm64 macOS 14.7.2 (Sonoma) GitHub AppleClang 15.0.0.15000100; Xcode 15.2 arm64 macOS 14.7.2 (Sonoma) GitHub AppleClang 15.0.0.15000309; Xcode 15.3 arm64 macOS 14.7.2 (Sonoma) GitHub AppleClang 15.0.0.15000309; Xcode 15.4 arm64 macOS 14.7.2 (Sonoma) GitHub AppleClang 16.0.0.16000026; Xcode 16 arm64 macOS 15.2 (Sequoia) GitHub AppleClang 16.0.0.16000026; Xcode 16.1 arm64 macOS 15.2 (Sequoia) GitHub AppleClang 16.0.0.16000026; Xcode 16.2 arm64 macOS 15.2 (Sequoia) GitHub AppleClang 17.0.0.17000013; Xcode 16.3 arm64 macOS 15.5 (Sequoia) GitHub AppleClang 17.0.0.17000013; Xcode 16.4 arm64 macOS 15.5 (Sequoia) GitHub AppleClang 17.0.0.17000319; Xcode 26.0.1 arm64 macOS 15.5 (Sequoia) GitHub Clang 3.4.2 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 3.5.2 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 3.6.2 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 3.7.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 3.8.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 3.9.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 4.0.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 5.0.2 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 6.0.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 7.1.0 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 8.0.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 9.0.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 10.0.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 11.0.1 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 11.1.0 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 12.0.1 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 12.0.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 13.0.1 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 13.0.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 14.0.6 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 14.0.6 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 15.0.7 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 15.0.7 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 16.0.6 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 16.0.6 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 17.0.6 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 18.1.8 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 18.1.8 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 19.1.5 with MSVC-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 19.1.7 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 19.1.7 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 20.1.1 x86_64 Ubuntu 22.04.1 LTS GitHub Clang 20.1.8 with GNU-like command-line x86_64 Windows Server 2022 (Build 20348) GitHub Clang 21.1.8 x86_64 Ubuntu 22.04.1 LTS GitHub CUDA 11.0.221 (nvcc) x86_64 Ubuntu 20.04 LTS GitHub Emscripten 4.0.6 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 4.8.5 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 4.9.3 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 5.5.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 6.4.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 7.5.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 8.5.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 9.3.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 9.4.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 9.5.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 10.5.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 11.4.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 11.5.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 12.2.0 (MinGW-W64 i686-ucrt-posix-dwarf) x86_64 Windows Server 2022 (Build 20348) GitHub GNU 12.2.0 (MinGW-W64 x86_64-ucrt-posix-seh) x86_64 Windows Server 2022 (Build 20348) GitHub GNU 12.4.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 13.3.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 14.2.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 15.1.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 16.1.0 x86_64 Ubuntu 22.04.1 LTS GitHub GNU 16.1.0 arm64 Linux 6.1.100 Cirrus CI icpc (ICC) 2021.5.0 20211109 x86_64 Ubuntu 20.04.3 LTS GitHub icpx (Intel oneAPI DPC++/C++) 2025.3.2 x86_64 Ubuntu 24.04 LTS GitHub nvc++ (NVIDIA HPC SDK) 25.5-0 x86_64 Ubuntu 22.04 LTS GitHub MSVC 19.0.24241.7 x86 Windows 8.1 AppVeyor MSVC 19.16.27035.0 x86 Windows-10 (Build 14393) AppVeyor MSVC 19.29.30157.0 x86 Windows-10 (Build 17763) AppVeyor MSVC 19.44.35207.0 arm64 Windows 11 (Build 26200) GitHub MSVC 19.44.35214.0 x86 Windows Server 2022 (Build 20348) GitHub MSVC 19.44.35214.0 x86_64 Windows Server 2022 (Build 20348) GitHub MSVC 19.51.36231.0 x86 Windows Server 2025 (Build 26100) GitHub MSVC 19.51.36231.0 x86_64 Windows Server 2025 (Build 26100) GitHubThe library is compiled with all C++ language revisions (C++11, C++14, C++17, C++20, C++23, and C++26) to detect and fix language deprecations early.
On Clang, -Weverything is used with 8 exceptions.
# Ignored Clang warnings:\n# -Wno-c++98-compat The library targets C++11.\n# -Wno-c++98-compat-pedantic The library targets C++11.\n# -Wno-deprecated-declarations The library contains annotations for deprecated functions.\n# -Wno-extra-semi-stmt The library uses assert which triggers this warning.\n# -Wno-padded We do not care about padding warnings.\n# -Wno-covered-switch-default All switches list all cases and a default case.\n# -Wno-unsafe-buffer-usage Otherwise Doctest would not compile.\n# -Wno-missing-noreturn We found no way to silence this warning otherwise, see PR #4871\n\nset(CLANG_CXXFLAGS\n -Werror\n -Weverything\n -Wno-c++98-compat\n -Wno-c++98-compat-pedantic\n -Wno-deprecated-declarations\n -Wno-extra-semi-stmt\n -Wno-padded\n -Wno-covered-switch-default\n -Wno-unsafe-buffer-usage\n -Wno-missing-noreturn\n)\nOn GCC, 300+ warnings are enabled with 8 exceptions.
GCC warnings# Warning flags determined for GCC 15.1.0 with https://github.com/nlohmann/gcc_flags:\n# Ignored GCC warnings:\n# -Wno-abi-tag We do not care about ABI tags.\n# -Wno-aggregate-return The library uses aggregate returns.\n# -Wno-long-long The library uses the long long type to interface with system functions.\n# -Wno-namespaces The library uses namespaces.\n# -Wno-nrvo Doctest triggers this warning.\n# -Wno-padded We do not care about padding warnings.\n# -Wno-system-headers We do not care about warnings in system headers.\n# -Wno-templates The library uses templates.\n\nset(GCC_CXXFLAGS\n -pedantic\n -Werror\n --all-warnings\n --extra-warnings\n -W\n -WNSObject-attribute\n -Wno-abi-tag\n -Waddress\n -Waddress-of-packed-member\n -Wno-aggregate-return\n -Waggressive-loop-optimizations\n -Waligned-new=all\n -Wall\n -Walloc-size\n -Walloc-zero\n -Walloca\n -Wanalyzer-allocation-size\n -Wanalyzer-deref-before-check\n -Wanalyzer-double-fclose\n -Wanalyzer-double-free\n -Wanalyzer-exposure-through-output-file\n -Wanalyzer-exposure-through-uninit-copy\n -Wanalyzer-fd-access-mode-mismatch\n -Wanalyzer-fd-double-close\n -Wanalyzer-fd-leak\n -Wanalyzer-fd-phase-mismatch\n -Wanalyzer-fd-type-mismatch\n -Wanalyzer-fd-use-after-close\n -Wanalyzer-fd-use-without-check\n -Wanalyzer-file-leak\n -Wanalyzer-free-of-non-heap\n -Wanalyzer-imprecise-fp-arithmetic\n -Wanalyzer-infinite-loop\n -Wanalyzer-infinite-recursion\n -Wanalyzer-jump-through-null\n -Wanalyzer-malloc-leak\n -Wanalyzer-mismatching-deallocation\n -Wanalyzer-null-argument\n -Wanalyzer-null-dereference\n -Wanalyzer-out-of-bounds\n -Wanalyzer-overlapping-buffers\n -Wanalyzer-possible-null-argument\n -Wanalyzer-possible-null-dereference\n -Wanalyzer-putenv-of-auto-var\n -Wanalyzer-shift-count-negative\n -Wanalyzer-shift-count-overflow\n -Wanalyzer-stale-setjmp-buffer\n -Wanalyzer-symbol-too-complex\n -Wanalyzer-tainted-allocation-size\n -Wanalyzer-tainted-array-index\n -Wanalyzer-tainted-assertion\n -Wanalyzer-tainted-divisor\n -Wanalyzer-tainted-offset\n -Wanalyzer-tainted-size\n -Wanalyzer-too-complex\n -Wanalyzer-undefined-behavior-ptrdiff\n -Wanalyzer-undefined-behavior-strtok\n -Wanalyzer-unsafe-call-within-signal-handler\n -Wanalyzer-use-after-free\n -Wanalyzer-use-of-pointer-in-stale-stack-frame\n -Wanalyzer-use-of-uninitialized-value\n -Wanalyzer-va-arg-type-mismatch\n -Wanalyzer-va-list-exhausted\n -Wanalyzer-va-list-leak\n -Wanalyzer-va-list-use-after-va-end\n -Wanalyzer-write-to-const\n -Wanalyzer-write-to-string-literal\n -Warith-conversion\n -Warray-bounds=2\n -Warray-compare\n -Warray-parameter=2\n -Wattribute-alias=2\n -Wattribute-warning\n -Wattributes\n -Wbool-compare\n -Wbool-operation\n -Wbuiltin-declaration-mismatch\n -Wbuiltin-macro-redefined\n -Wc++0x-compat\n -Wc++11-compat\n -Wc++11-extensions\n -Wc++14-compat\n -Wc++14-extensions\n -Wc++17-compat\n -Wc++17-extensions\n -Wc++1z-compat\n -Wc++20-compat\n -Wc++20-extensions\n -Wc++23-extensions\n -Wc++26-extensions\n -Wc++2a-compat\n -Wcalloc-transposed-args\n -Wcannot-profile\n -Wcast-align\n -Wcast-align=strict\n -Wcast-function-type\n -Wcast-qual\n -Wcast-user-defined\n -Wcatch-value=3\n -Wchanges-meaning\n -Wchar-subscripts\n -Wclass-conversion\n -Wclass-memaccess\n -Wclobbered\n -Wcomma-subscript\n -Wcomment\n -Wcomments\n -Wcomplain-wrong-lang\n -Wconditionally-supported\n -Wconversion\n -Wconversion-null\n -Wcoverage-invalid-line-number\n -Wcoverage-mismatch\n -Wcoverage-too-many-conditions\n -Wcoverage-too-many-paths\n -Wcpp\n -Wctad-maybe-unsupported\n -Wctor-dtor-privacy\n -Wdangling-else\n -Wdangling-pointer=2\n -Wdangling-reference\n -Wdate-time\n -Wdefaulted-function-deleted\n -Wdelete-incomplete\n -Wdelete-non-virtual-dtor\n -Wdeprecated\n -Wdeprecated-copy\n -Wdeprecated-copy-dtor\n -Wdeprecated-declarations\n -Wdeprecated-enum-enum-conversion\n -Wdeprecated-enum-float-conversion\n -Wdeprecated-literal-operator\n -Wdeprecated-variadic-comma-omission\n -Wdisabled-optimization\n -Wdiv-by-zero\n -Wdouble-promotion\n -Wduplicated-branches\n -Wduplicated-cond\n -Weffc++\n -Welaborated-enum-base\n -Wempty-body\n -Wendif-labels\n -Wenum-compare\n -Wenum-conversion\n -Wexceptions\n -Wexpansion-to-defined\n -Wextra\n -Wextra-semi\n -Wflex-array-member-not-at-end\n -Wfloat-conversion\n -Wfloat-equal\n -Wformat -Wformat-contains-nul\n -Wformat -Wformat-diag\n -Wformat -Wformat-extra-args\n -Wformat -Wformat-nonliteral\n -Wformat -Wformat-overflow=2\n -Wformat -Wformat-security\n -Wformat -Wformat-signedness\n -Wformat -Wformat-truncation=2\n -Wformat -Wformat-y2k\n -Wformat -Wformat-zero-length\n -Wformat=2\n -Wframe-address\n -Wfree-nonheap-object\n -Wglobal-module\n -Whardened\n -Wheader-guard\n -Whsa\n -Wif-not-aligned\n -Wignored-attributes\n -Wignored-qualifiers\n -Wimplicit-fallthrough=5\n -Winaccessible-base\n -Winfinite-recursion\n -Winherited-variadic-ctor\n -Winit-list-lifetime\n -Winit-self\n -Winline\n -Wint-in-bool-context\n -Wint-to-pointer-cast\n -Winterference-size\n -Winvalid-constexpr\n -Winvalid-imported-macros\n -Winvalid-memory-model\n -Winvalid-offsetof\n -Winvalid-pch\n -Winvalid-utf8\n -Wliteral-suffix\n -Wlogical-not-parentheses\n -Wlogical-op\n -Wno-long-long\n -Wlto-type-mismatch\n -Wmain\n -Wmaybe-musttail-local-addr\n -Wmaybe-uninitialized\n -Wmemset-elt-size\n -Wmemset-transposed-args\n -Wmisleading-indentation\n -Wmismatched-dealloc\n -Wmismatched-new-delete\n -Wmismatched-tags\n -Wmissing-attributes\n -Wmissing-braces\n -Wmissing-declarations\n -Wmissing-field-initializers\n -Wmissing-include-dirs\n -Wmissing-profile\n -Wmissing-requires\n -Wmissing-template-keyword\n -Wmultichar\n -Wmultiple-inheritance\n -Wmultistatement-macros\n -Wmusttail-local-addr\n -Wno-namespaces\n -Wnarrowing\n -Wnoexcept\n -Wnoexcept-type\n -Wnon-template-friend\n -Wnon-virtual-dtor\n -Wnonnull\n -Wnonnull-compare\n -Wnormalized=nfkc\n -Wno-nrvo\n -Wnull-dereference\n -Wodr\n -Wold-style-cast\n -Wopenacc-parallelism\n -Wopenmp\n -Wopenmp-simd\n -Woverflow\n -Woverlength-strings\n -Woverloaded-virtual=2\n -Wpacked\n -Wpacked-bitfield-compat\n -Wpacked-not-aligned\n -Wno-padded\n -Wparentheses\n -Wpedantic\n -Wpessimizing-move\n -Wplacement-new=2\n -Wpmf-conversions\n -Wpointer-arith\n -Wpointer-compare\n -Wpragma-once-outside-header\n -Wpragmas\n -Wprio-ctor-dtor\n -Wpsabi\n -Wrange-loop-construct\n -Wredundant-decls\n -Wredundant-move\n -Wredundant-tags\n -Wregister\n -Wreorder\n -Wrestrict\n -Wreturn-local-addr\n -Wreturn-type\n -Wscalar-storage-order\n -Wself-move\n -Wsequence-point\n -Wshadow=compatible-local\n -Wshadow=global\n -Wshadow=local\n -Wshift-count-negative\n -Wshift-count-overflow\n -Wshift-negative-value\n -Wshift-overflow=2\n -Wsign-compare\n -Wsign-conversion\n -Wsign-promo\n -Wsized-deallocation\n -Wsizeof-array-argument\n -Wsizeof-array-div\n -Wsizeof-pointer-div\n -Wsizeof-pointer-memaccess\n -Wstack-protector\n -Wstrict-aliasing\n -Wstrict-aliasing=3\n -Wstrict-null-sentinel\n -Wstrict-overflow\n -Wstring-compare\n -Wstringop-overflow\n -Wstringop-overflow=4\n -Wstringop-overread\n -Wstringop-truncation\n -Wsubobject-linkage\n -Wsuggest-attribute=cold\n -Wsuggest-attribute=const\n -Wsuggest-attribute=format\n -Wsuggest-attribute=malloc\n -Wsuggest-attribute=noreturn\n -Wsuggest-attribute=pure\n -Wsuggest-attribute=returns_nonnull\n -Wsuggest-final-methods\n -Wsuggest-final-types\n -Wsuggest-override\n -Wswitch\n -Wswitch-bool\n -Wswitch-default\n -Wswitch-enum\n -Wswitch-outside-range\n -Wswitch-unreachable\n -Wsync-nand\n -Wsynth\n -Wno-system-headers\n -Wtautological-compare\n -Wtemplate-body\n -Wtemplate-id-cdtor\n -Wtemplate-names-tu-local\n -Wno-templates\n -Wterminate\n -Wtrailing-whitespace\n -Wtrampolines\n -Wtrigraphs\n -Wtrivial-auto-var-init\n -Wtsan\n -Wtype-limits\n -Wundef\n -Wunicode\n -Wuninitialized\n -Wunknown-pragmas\n -Wunreachable-code\n -Wunsafe-loop-optimizations\n -Wunused\n -Wunused-but-set-parameter\n -Wunused-but-set-variable\n -Wunused-const-variable=2\n -Wunused-function\n -Wunused-label\n -Wunused-local-typedefs\n -Wunused-macros\n -Wunused-parameter\n -Wunused-result\n -Wunused-value\n -Wunused-variable\n -Wuse-after-free=3\n -Wuseless-cast\n -Wvarargs\n -Wvariadic-macros\n -Wvector-operation-performance\n -Wvexing-parse\n -Wvirtual-inheritance\n -Wvirtual-move-assign\n -Wvla\n -Wvla-parameter\n -Wvolatile\n -Wvolatile-register-var\n -Wwrite-strings\n -Wxor-used-as-pow\n -Wzero-as-null-pointer-constant\n -Wzero-length-bounds\n)\nRequirement: No prerequisites
The library has no prerequisites other than the Standard Template Library (STL).
<Windows.h> being included to detect and avoid common bugs.Requirement: Stable public API
Any change to the library does not break the public API.
Requirement: Complete documentation
The public API is extensively documented.
Requirement: Standards compliance
The library is compliant to JSON as defined in RFC 8259.
Requirement: State-of-the-art code analysis
The code is checked with state-of-the-art static code analysis tools.
The code is checked with the latest Clang-Tidy.
Clang-Tidy configuration (.clang-tidy)# TODO: The first three checks are only removed to get the CI going. They have to be addressed at some point.\n# TODO: portability-avoid-pragma-once: should be fixed eventually\n\nChecks: '*,\n\n -portability-template-virtual-member-function,\n -bugprone-use-after-move,\n -hicpp-invalid-access-moved,\n\n -altera-id-dependent-backward-branch,\n -altera-struct-pack-align,\n -altera-unroll-loops,\n -android-cloexec-fopen,\n -boost-use-ranges,\n -bugprone-easily-swappable-parameters,\n -cert-err58-cpp,\n -clang-analyzer-webkit.NoUncountedMemberChecker,\n -concurrency-mt-unsafe,\n -cppcoreguidelines-avoid-const-or-ref-data-members,\n -cppcoreguidelines-avoid-do-while,\n -cppcoreguidelines-avoid-goto,\n -cppcoreguidelines-avoid-magic-numbers,\n -cppcoreguidelines-avoid-non-const-global-variables,\n -cppcoreguidelines-macro-usage,\n -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,\n -cppcoreguidelines-pro-bounds-array-to-pointer-decay,\n -cppcoreguidelines-pro-bounds-constant-array-index,\n -cppcoreguidelines-pro-bounds-pointer-arithmetic,\n -cppcoreguidelines-pro-type-reinterpret-cast,\n -cppcoreguidelines-pro-type-union-access,\n -cppcoreguidelines-rvalue-reference-param-not-moved,\n -cppcoreguidelines-virtual-class-destructor,\n -fuchsia-default-arguments-calls,\n -fuchsia-default-arguments-declarations,\n -fuchsia-overloaded-operator,\n -google-explicit-constructor,\n -google-readability-function-size,\n -google-runtime-float,\n -google-runtime-int,\n -google-runtime-references,\n -hicpp-avoid-goto,\n -hicpp-explicit-conversions,\n -hicpp-function-size,\n -hicpp-no-array-decay,\n -hicpp-no-assembler,\n -hicpp-signed-bitwise,\n -hicpp-uppercase-literal-suffix,\n -llvm-header-guard,\n -llvm-include-order,\n -llvm-prefer-static-over-anonymous-namespace,\n -llvm-use-ranges,\n -llvmlibc-*,\n -misc-use-anonymous-namespace,\n -misc-confusable-identifiers,\n -misc-include-cleaner,\n -misc-no-recursion,\n -misc-non-private-member-variables-in-classes,\n -modernize-concat-nested-namespaces,\n -modernize-type-traits,\n -modernize-use-constraints,\n -modernize-use-designated-initializers,\n -modernize-use-nodiscard,\n -modernize-use-ranges,\n -modernize-use-std-numbers,\n -modernize-use-trailing-return-type,\n -performance-enum-size,\n -portability-avoid-pragma-once,\n -readability-function-cognitive-complexity,\n -readability-function-size,\n -readability-identifier-length,\n -readability-magic-numbers,\n -readability-redundant-access-specifiers,\n -readability-redundant-parentheses,\n -readability-simplify-boolean-expr,\n -readability-uppercase-literal-suffix,\n -readability-use-concise-preprocessor-directives'\n\nCheckOptions:\n - key: hicpp-special-member-functions.AllowSoleDefaultDtor\n value: 1\n\nWarningsAsErrors: '*'\n\n#HeaderFilterRegex: '.*nlohmann.*'\nHeaderFilterRegex: '.*hpp$'\nThe code is checked with the latest Cppcheck with all warnings enabled.
Requirement: Correctness
The library is checked for memory correctness and absence of undefined behavior.
Requirement: Common code style
A common code style is used throughout all code files of the library.
The code is formatted with Artistic Style (astyle) against a style configuration that is also enforced in the CI.
Astyle configuration (tools/astyle/.astylerc)# Configuration for Artistic Style\n# see https://astyle.sourceforge.net/astyle.html\n\n#######################\n# Brace Style Options #\n#######################\n\n# use Allman style for braces\n--style=allman\n\n###############\n# Tab Options #\n###############\n\n# indent using 4 spaces\n--indent=spaces=4\n\n#######################\n# Indentation Options #\n#######################\n\n# indent access modifiers one half indent\n--indent-modifiers\n\n# indent switch cases to the switch block\n--indent-switches\n\n# indent preprocessor blocks\n--indent-preproc-block\n\n# indent preprocessor defines\n--indent-preproc-define\n\n# indent C++ comments\n--indent-col1-comments\n\n###################\n# Padding Options #\n###################\n\n# insert space padding around operators\n--pad-oper\n\n# insert space between if/for/while... and the following parentheses\n--pad-header\n\n# attach the pointer to the variable type (left)\n--align-pointer=type\n\n# attach the reference to the variable type (left)\n--align-reference=type\n\n######################\n# Formatting Options #\n######################\n\n# add braces to unbraced one line conditional statements\n--add-braces\n\n# convert tabs to spaces\n--convert-tabs\n\n# closes whitespace between the ending angle brackets of template definitions\n--close-templates\n\n#################\n# Other Options #\n#################\n\n# do not create backup files\n--suffix=none\n\n# preserve the original file date\n--preserve-date\n\n# display only the files that have been formatted\n--formatted\n\n# for the linux (LF) line end style\n--lineend=linux\nThe code style is checked with cpplint with 61 enabled rules.
Requirement: Single header
The library can be used by adding a single header to a C++ project.
Requirement: CMake as primary development tool
All library functions are exposed and usable by CMake.
We value the security of our users and appreciate your efforts to responsibly disclose vulnerabilities. If you have identified a security vulnerability in this repository, please use the GitHub Security Advisory \"Report a Vulnerability\" tab.
Until it is published, this draft security advisory will only be visible to the maintainers of this project. Other users and teams may be added once the advisory is created.
We will send a response indicating the next steps in handling your report. After the initial reply to your report, we will keep you informed of the progress towards a fix and full announcement and may ask for additional information or guidance.
For vulnerabilities in third-party dependencies or modules, please report them directly to the respective maintainers.
"},{"location":"community/security_policy/#additional-resources","title":"Additional Resources","text":"We sincerely thank you for contributing to the security and integrity of this project!
"},{"location":"features/","title":"Features","text":"This section describes the features of the library in detail. If you are new to the library, the pages below are roughly ordered along a typical workflow: create or parse a value, access and modify it, convert it to and from your own C++ types, and finally serialize it again.
"},{"location":"features/#creating-and-reading-values","title":"Creating and reading values","text":"{} vs. [] ambiguity.operator[]), checked (at), and access with a default value.get/get_to, and understand implicit conversions.dump, including pretty-printing and handling of non-ASCII and invalid UTF-8.ordered_json.nlohmann namespace, and C++ modules \u2014 build-time and runtime configuration.Looking for a specific function?
This section gives conceptual overviews. For the precise signature, parameters, and return value of a function, see the API Documentation.
"},{"location":"features/arbitrary_types/","title":"Arbitrary Type Conversions","text":"Every type can be serialized in JSON, not just STL containers and scalar types. Usually, you would do something along those lines:
namespace ns {\n // a simple struct to model a person\n struct person {\n std::string name;\n std::string address;\n int age;\n };\n} // namespace ns\n\nns::person p = {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n// convert to JSON: copy each value into the JSON object\njson j;\nj[\"name\"] = p.name;\nj[\"address\"] = p.address;\nj[\"age\"] = p.age;\n\n// ...\n\n// convert from JSON: copy each value from the JSON object\nns::person p {\n j[\"name\"].get<std::string>(),\n j[\"address\"].get<std::string>(),\n j[\"age\"].get<int>()\n};\nIt works, but that's quite a lot of boilerplate... Fortunately, there's a better way:
// create a person\nns::person p {\"Ned Flanders\", \"744 Evergreen Terrace\", 60};\n\n// conversion: person -> json\njson j = p;\n\nstd::cout << j << std::endl;\n// {\"address\":\"744 Evergreen Terrace\",\"age\":60,\"name\":\"Ned Flanders\"}\n\n// conversion: json -> person\nauto p2 = j.get<ns::person>();\n\n// that's it\nassert(p == p2);\nTo make this work with one of your types, you only need to provide two functions:
using json = nlohmann::json;\n\nnamespace ns {\n void to_json(json& j, const person& p) {\n j = json{ {\"name\", p.name}, {\"address\", p.address}, {\"age\", p.age} };\n }\n\n void from_json(const json& j, person& p) {\n j.at(\"name\").get_to(p.name);\n j.at(\"address\").get_to(p.address);\n j.at(\"age\").get_to(p.age);\n }\n} // namespace ns\nThat's all! When calling the json constructor with your type, your custom to_json method will be automatically called. Likewise, when calling get<your_type>() or get_to(your_type&), the from_json method will be called.
Some important things:
ns, where person is defined).get<your_type>(), your_type MUST be DefaultConstructible. (There is a way to bypass this requirement described later.)from_json, use function at() to access the object values rather than operator[]. In case a key does not exist, at throws an exception that you can handle, whereas operator[] exhibits undefined behavior.std::vector: the library already implements these.If you just want to serialize/deserialize some structs, the to_json/from_json functions can be a lot of boilerplate.
There are several macros to make your life easier as long as you want to use a JSON object as serialization. The macros are following the naming pattern, and you can choose the macro based on the needed features:
NLOHMANN_DEFINE.DERIVED_TYPE variant, otherwise use TYPE.DERIVED_TYPE variant requires an additional parameter of a base type, which should have the to_json/from_json functions defined. For instance, with a macro of its own.INTRUSIVE variant, otherwise use NON_INTRUSIVE.INTRUSIVE macro should be defined inside the target class/struct, NON_INTRUSIVE should be defined within the same namespace.WITH_DEFAULTS variant, which will use the default values for the member variables absent in JSON, the variant without WITH_DEFAULTS will raise an exception.to_json function, you can use the ONLY_SERIALIZE variant.WITH_NAMES variant, otherwise the JSON name of the variable will be the same as its regular name. For all the macros, the first parameter is the name of the class/struct. The DERIVED_TYPE macros require a second parameter of a base class. All the remaining parameters name the member variables. The WITH_NAMES macros require a JSON name before each of the variables.
For derived classes and structs, use the following macros
Need access to private members Need only de-serialization Allow missing values when de-serializing macro NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZEImplementation limits
to_json/from_json functions manually.WITH_NAMES variants the limit is halved to 31 member variables.The to_json/from_json functions for the person struct above can be created with:
namespace ns {\n NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)\n}\nIf you want to inherit the person struct and add a field to it, it can be done with:
namespace ns {\n struct person_derived : person {\n std::string email;\n };\n\n NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(person_derived, person, email)\n}\nHere is another example with private members, where NLOHMANN_DEFINE_TYPE_INTRUSIVE is needed:
namespace ns {\n class address {\n private:\n std::string street;\n int housenumber;\n int postcode;\n\n public:\n NLOHMANN_DEFINE_TYPE_INTRUSIVE(address, street, housenumber, postcode)\n };\n}\nOr in case if you use some naming convention that you do not want to expose to JSON:
namespace ns {\n class address {\n private:\n std::string m_street;\n int m_housenumber;\n int m_postcode;\n\n public:\n NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_NAMES(address, \"street\", m_street,\n \"housenumber\", m_housenumber,\n \"postcode\", m_postcode)\n };\n}\nThis requires a bit more advanced technique. But first, let us see how this conversion mechanism works:
The library uses JSON Serializers to convert types to JSON. The default serializer for nlohmann::json is nlohmann::adl_serializer (ADL means Argument-Dependent Lookup).
It is implemented like this (simplified):
template <typename T>\nstruct adl_serializer {\n static void to_json(json& j, const T& value) {\n // calls the \"to_json\" method in T's namespace\n }\n\n static void from_json(const json& j, T& value) {\n // same thing, but with the \"from_json\" method\n }\n};\nThis serializer works fine when you have control over the type's namespace. However, what about boost::optional or std::filesystem::path (C++17)? Hijacking the boost namespace is pretty bad, and it's illegal to add something other than template specializations to std...
To solve this, you need to add a specialization of adl_serializer to the nlohmann namespace, here's an example:
// partial specialization (full specialization works too)\nNLOHMANN_JSON_NAMESPACE_BEGIN\ntemplate <typename T>\nstruct adl_serializer<boost::optional<T>> {\n static void to_json(json& j, const boost::optional<T>& opt) {\n if (opt == boost::none) {\n j = nullptr;\n } else {\n j = *opt; // this will call adl_serializer<T>::to_json which will\n // find the free function to_json in T's namespace!\n }\n }\n\n static void from_json(const json& j, boost::optional<T>& opt) {\n if (j.is_null()) {\n opt = boost::none;\n } else {\n opt = j.get<T>(); // same as above, but with\n // adl_serializer<T>::from_json\n }\n }\n};\nNLOHMANN_JSON_NAMESPACE_END\nABI compatibility
Use NLOHMANN_JSON_NAMESPACE_BEGIN and NLOHMANN_JSON_NAMESPACE_END instead of namespace nlohmann { } in code which may be linked with different versions of this library.
get() for non-default constructible/non-copyable types?","text":"There is a way if your type is MoveConstructible. You will need to specialize the adl_serializer as well, but with a special from_json overload:
struct move_only_type {\n move_only_type() = delete;\n move_only_type(int ii): i(ii) {}\n move_only_type(const move_only_type&) = delete;\n move_only_type(move_only_type&&) = default;\n\n int i;\n};\n\nnamespace nlohmann {\n template <>\n struct adl_serializer<move_only_type> {\n // note: the return type is no longer 'void', and the method only takes\n // one argument\n static move_only_type from_json(const json& j) {\n return {j.get<int>()};\n }\n\n // Here's the catch! You must provide a to_json method! Otherwise, you\n // will not be able to convert move_only_type to json, since you fully\n // specialized adl_serializer on that type\n static void to_json(json& j, move_only_type t) {\n j = t.i;\n }\n };\n}\nYes. You might want to take a look at unit-udt.cpp in the test suite, to see a few examples.
If you write your own serializer, you will need to do a few things:
basic_json alias than nlohmann::json (the last template parameter of basic_json is the JSONSerializer)basic_json alias (or a template parameter) in all your to_json/from_json methodsnlohmann::to_json and nlohmann::from_json when you need ADLHere is an example, without simplifications, that only accepts types with a size <= 32, and uses ADL.
// You should use void as a second template argument\n// if you don't need compile-time checks on T\ntemplate<typename T, typename SFINAE = typename std::enable_if<sizeof(T) <= 32>::type>\nstruct less_than_32_serializer {\n template <typename BasicJsonType>\n static void to_json(BasicJsonType& j, T value) {\n // we want to use ADL, and call the correct to_json overload\n using nlohmann::to_json; // this method is called by adl_serializer,\n // this is where the magic happens\n to_json(j, value);\n }\n\n template <typename BasicJsonType>\n static void from_json(const BasicJsonType& j, T& value) {\n // same thing here\n using nlohmann::from_json;\n from_json(j, value);\n }\n};\nBe very careful when reimplementing your serializer, you can stack overflow if you don't pay attention:
template <typename T, void>\nstruct bad_serializer\n{\n template <typename BasicJsonType>\n static void to_json(BasicJsonType& j, const T& value) {\n // this calls BasicJsonType::json_serializer<T>::to_json(j, value);\n // if BasicJsonType::json_serializer == bad_serializer ... oops!\n j = value;\n }\n\n template <typename BasicJsonType>\n static void from_json(const BasicJsonType& j, T& value) {\n // this calls BasicJsonType::json_serializer<T>::from_json(j, value);\n // if BasicJsonType::json_serializer == bad_serializer ... oops!\n value = j.template get<T>(); // oops!\n }\n};\nThe code contains numerous debug assertions to ensure class invariants are valid or to detect undefined behavior. Whereas the former class invariants are nothing to be concerned with, the latter checks for undefined behavior are to detect bugs in client code.
"},{"location":"features/assertions/#switch-off-runtime-assertions","title":"Switch off runtime assertions","text":"Runtime assertions can be switched off by defining the preprocessor macro NDEBUG (see the documentation of assert) which is the default for release builds.
The behavior of runtime assertions can be changed by defining macro JSON_ASSERT(x) before including the json.hpp header.
Function operator[] implements unchecked access for objects. Whereas a missing key is added in the case of non-const objects, accessing a const object with a missing key is undefined behavior (think of a dereferenced null pointer) and yields a runtime assertion.
If you are not sure whether an element in an object exists, use checked access with the at function or call the contains function before.
See also the documentation on element access.
Example 1: Missing object keyThe following code will trigger an assertion at runtime:
#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n const json j = {{\"key\", \"value\"}};\n auto v = j[\"missing\"];\n}\nOutput:
Assertion failed: (m_value.object->find(key) != m_value.object->end()), function operator[], file json.hpp, line 2144.\nConstructing a JSON value from an iterator range (see constructor) with an uninitialized iterator is undefined behavior and yields a runtime assertion.
Example 2: Uninitialized iterator rangeThe following code will trigger an assertion at runtime:
#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json::iterator it1, it2;\n json j(it1, it2);\n}\nOutput:
Assertion failed: (m_object != nullptr), function operator++, file iter_impl.hpp, line 368.\nAny operation on uninitialized iterators (i.e., iterators that are not associated with any JSON value) is undefined behavior and yields a runtime assertion.
Example 3: Uninitialized iteratorThe following code will trigger an assertion at runtime:
#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json::iterator it;\n ++it;\n}\nOutput:
Assertion failed: (m_object != nullptr), function operator++, file iter_impl.hpp, line 368.\nFILE or char pointer","text":"Reading from a null FILE or char pointer in C++ is undefined behavior. Until version 3.12.0, this library asserted that the pointer was not nullptr using a runtime assertion. If assertions were disabled, this would result in undefined behavior. Since version 3.12.0, this library checks for nullptr and throws a parse_error.101 to prevent the undefined behavior.
The following code will trigger an assertion at runtime:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::FILE* f = std::fopen(\"nonexistent_file.json\", \"r\");\n try {\n json j = json::parse(f);\n } catch (std::exception& e) {\n std::cerr << e.what() << std::endl;\n }\n}\nOutput:
[json.exception.parse_error.101] parse error: attempting to parse an empty input; check that your input string or stream contains the expected JSON\nThe library implements several binary formats that encode JSON in an efficient way. Most of these formats support binary values; that is, values that have semantics defined outside the library and only define a sequence of bytes to be stored.
JSON itself does not have a binary value. As such, binary values are an extension that this library implements to store values received by a binary format. Binary values are never created by the JSON parser and are only part of a serialized JSON text if they have been created manually or via a binary format.
"},{"location":"features/binary_values/#api-for-binary-values","title":"API for binary values","text":"classDiagram\n\nclass binary_t [\"json::binary_t\"] {\n +void set_subtype(std::uint64_t subtype)\n +void clear_subtype()\n +std::uint64_t subtype() const\n +bool has_subtype() const\n}\n\nclass vector [\"std::vector<uint8_t>\"]\n\nvector <|-- binary_tBy default, binary values are stored as std::vector<std::uint8_t>. This type can be changed by providing a template parameter to the basic_json type. To store binary subtypes, the storage type is extended and exposed as json::binary_t:
auto binary = json::binary_t({0xCA, 0xFE, 0xBA, 0xBE});\nauto binary_with_subtype = json::binary_t({0xCA, 0xFE, 0xBA, 0xBE}, 42);\nThere are several convenience functions to check and set the subtype:
binary.has_subtype(); // returns false\nbinary_with_subtype.has_subtype(); // returns true\n\nbinary_with_subtype.clear_subtype();\nbinary_with_subtype.has_subtype(); // returns false\n\nbinary_with_subtype.set_subtype(42);\nbinary.set_subtype(23);\n\nbinary.subtype(); // returns 23\nAs json::binary_t is subclassing std::vector<std::uint8_t>, all member functions are available:
binary.size(); // returns 4\nbinary[1]; // returns 0xFE\nJSON values can be constructed from json::binary_t:
json j = binary;\nBinary values are primitive values just like numbers or strings:
j.is_binary(); // returns true\nj.is_primitive(); // returns true\nGiven a binary JSON value, the binary_t can be accessed by reference as via get_binary():
j.get_binary().has_subtype(); // returns true\nj.get_binary().size(); // returns 4\nFor convenience, binary JSON values can be constructed via json::binary:
auto j2 = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 23);\nauto j3 = json::binary({0xCA, 0xFE, 0xBA, 0xBE});\n\nj2 == j; // returns true\nj3.get_binary().has_subtype(); // returns false\nj3.get_binary().subtype(); // returns std::uint64_t(-1) as j3 has no subtype\nBinary values are serialized differently according to the formats.
"},{"location":"features/binary_values/#json","title":"JSON","text":"JSON does not have a binary type, and this library does not introduce a new type as this would break conformance. Instead, binary values are serialized as an object with two keys: bytes holds an array of integers, and subtype is an integer or null.
Code:
// create a binary value of subtype 42\njson j;\nj[\"binary\"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);\n\n// serialize to standard output\nstd::cout << j.dump(2) << std::endl;\nOutput:
{\n \"binary\": {\n \"bytes\": [202, 254, 186, 190],\n \"subtype\": 42\n }\n}\nNo roundtrip for binary values
The JSON parser will not parse the objects generated by binary values back to binary values. This is by design to remain standards compliant. Serializing binary values to JSON is only implemented for debugging purposes.
"},{"location":"features/binary_values/#bjdata","title":"BJData","text":"BJData neither supports binary values nor subtypes and proposes to serialize binary values as an array of uint8 values. The library implements this translation.
ExampleCode:
// create a binary value of subtype 42 (will be ignored in BJData)\njson j;\nj[\"binary\"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);\n\n// convert to BJData\nauto v = json::to_bjdata(j); \nv is a std::vector<std::uint8_t> with the following 20 elements:
0x7B // '{'\n 0x69 0x06 // i 6 (length of the key)\n 0x62 0x69 0x6E 0x61 0x72 0x79 // \"binary\"\n 0x5B // '['\n 0x55 0xCA 0x55 0xFE 0x55 0xBA 0x55 0xBE // content (each byte prefixed with 'U')\n 0x5D // ']'\n0x7D // '}'\nThe following code uses the type and size optimization for BJData:
// convert to BJData using the size and type optimization\nauto v = json::to_bjdata(j, true, true);\nThe resulting vector has 22 elements; the optimization is not effective for examples with few values:
0x7B // '{'\n 0x23 0x69 0x01 // '#' 'i' type of the array elements: unsigned integers\n 0x69 0x06 // i 6 (length of the key)\n 0x62 0x69 0x6E 0x61 0x72 0x79 // \"binary\"\n 0x5B // '[' array\n 0x24 0x55 // '$' 'U' type of the array elements: unsigned integers\n 0x23 0x69 0x04 // '#' i 4 number of array elements\n 0xCA 0xFE 0xBA 0xBE // content\nNote that subtype (42) is not serialized and that BJData has no binary type, and deserializing v would yield the following value:
{\n \"binary\": [202, 254, 186, 190]\n}\nBSON supports binary values and subtypes. If a subtype is given, it is used and added as an unsigned 8-bit integer. If no subtype is given, the generic binary subtype 0x00 is used.
ExampleCode:
// create a binary value of subtype 42\njson j;\nj[\"binary\"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);\n\n// convert to BSON\nauto v = json::to_bson(j); \nv is a std::vector<std::uint8_t> with the following 22 elements:
0x16 0x00 0x00 0x00 // number of bytes in the document\n 0x05 // binary value\n 0x62 0x69 0x6E 0x61 0x72 0x79 0x00 // key \"binary\" + null byte\n 0x04 0x00 0x00 0x00 // number of bytes\n 0x2a // subtype\n 0xCA 0xFE 0xBA 0xBE // content\n0x00 // end of the document\nNote that the serialization preserves the subtype, and deserializing v would yield the following value:
{\n \"binary\": {\n \"bytes\": [202, 254, 186, 190],\n \"subtype\": 42\n }\n}\nCBOR supports binary values, but no subtypes. Subtypes will be serialized as tags. Any binary value will be serialized as byte strings. The library will choose the smallest representation using the length of the byte array.
ExampleCode:
// create a binary value of subtype 42\njson j;\nj[\"binary\"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);\n\n// convert to CBOR\nauto v = json::to_cbor(j); \nv is a std::vector<std::uint8_t> with the following 15 elements:
0xA1 // map(1)\n 0x66 // text(6)\n 0x62 0x69 0x6E 0x61 0x72 0x79 // \"binary\"\n 0xD8 0x2A // tag(42)\n 0x44 // bytes(4)\n 0xCA 0xFE 0xBA 0xBE // content\nNote that the subtype is serialized as tag. However, parsing tagged values yield a parse error unless json::cbor_tag_handler_t::ignore or json::cbor_tag_handler_t::store is passed to json::from_cbor.
{\n \"binary\": {\n \"bytes\": [202, 254, 186, 190],\n \"subtype\": null\n }\n}\nMessagePack supports binary values and subtypes. If a subtype is given, the ext family is used. The library will choose the smallest representation among fixext1, fixext2, fixext4, fixext8, ext8, ext16, and ext32. The subtype is then added as a signed 8-bit integer.
If no subtype is given, the bin family (bin8, bin16, bin32) is used.
ExampleCode:
// create a binary value of subtype 42\njson j;\nj[\"binary\"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);\n\n// convert to MessagePack\nauto v = json::to_msgpack(j); \nv is a std::vector<std::uint8_t> with the following 14 elements:
0x81 // fixmap1\n 0xA6 // fixstr6\n 0x62 0x69 0x6E 0x61 0x72 0x79 // \"binary\"\n 0xD6 // fixext4\n 0x2A // subtype\n 0xCA 0xFE 0xBA 0xBE // content\nNote that the serialization preserves the subtype, and deserializing v would yield the following value:
{\n \"binary\": {\n \"bytes\": [202, 254, 186, 190],\n \"subtype\": 42\n }\n}\nUBJSON neither supports binary values nor subtypes and proposes to serialize binary values as an array of uint8 values. The library implements this translation.
ExampleCode:
// create a binary value of subtype 42 (will be ignored in UBJSON)\njson j;\nj[\"binary\"] = json::binary({0xCA, 0xFE, 0xBA, 0xBE}, 42);\n\n// convert to UBJSON\nauto v = json::to_ubjson(j); \nv is a std::vector<std::uint8_t> with the following 20 elements:
0x7B // '{'\n 0x69 0x06 // i 6 (length of the key)\n 0x62 0x69 0x6E 0x61 0x72 0x79 // \"binary\"\n 0x5B // '['\n 0x55 0xCA 0x55 0xFE 0x55 0xBA 0x55 0xBE // content (each byte prefixed with 'U')\n 0x5D // ']'\n0x7D // '}'\nThe following code uses the type and size optimization for UBJSON:
// convert to UBJSON using the size and type optimization\nauto v = json::to_ubjson(j, true, true);\nThe resulting vector has 23 elements; the optimization is not effective for examples with few values:
0x7B // '{'\n 0x24 // '$' type of the object elements\n 0x5B // '[' array\n 0x23 0x69 0x01 // '#' i 1 number of object elements\n 0x69 0x06 // i 6 (length of the key)\n 0x62 0x69 0x6E 0x61 0x72 0x79 // \"binary\"\n 0x24 0x55 // '$' 'U' type of the array elements: unsigned integers\n 0x23 0x69 0x04 // '#' i 4 number of array elements\n 0xCA 0xFE 0xBA 0xBE // content\nNote that subtype (42) is not serialized and that UBJSON has no binary type, and deserializing v would yield the following value:
{\n \"binary\": [202, 254, 186, 190]\n}\nThis library does not support comments by default. It does so for three reasons:
// or /* */ are allowed in JavaScript, but JSON is not JavaScript.This was not an oversight: Douglas Crockford wrote on this in May 2012:
I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability. I know that the lack of comments makes some people sad, but it shouldn't.
Suppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.
It is dangerous for interoperability if some libraries add comment support while others do not. Please check The Harmful Consequences of the Robustness Principle on this.
However, you can set parameter ignore_comments to true in the parse function to ignore // or /* */ comments. Comments will then be treated as whitespace.
For more information, see JSON With Commas and Comments (JWCC).
Example
Consider the following JSON with comments.
{\n // update in 2006: removed Pluto\n \"planets\": [\"Mercury\", \"Venus\", \"Earth\", \"Mars\",\n \"Jupiter\", \"Uranus\", \"Neptune\" /*, \"Pluto\" */]\n}\nWhen calling parse without additional argument, a parse error exception is thrown. If ignore_comments is set to true, the comments are ignored during parsing:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::string s = R\"(\n {\n // update in 2006: removed Pluto\n \"planets\": [\"Mercury\", \"Venus\", \"Earth\", \"Mars\",\n \"Jupiter\", \"Uranus\", \"Neptune\" /*, \"Pluto\" */]\n }\n )\";\n\n try\n {\n json j = json::parse(s);\n }\n catch (json::exception& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n json j = json::parse(s,\n /* callback */ nullptr,\n /* allow exceptions */ true,\n /* ignore_comments */ true);\n std::cout << j.dump(2) << '\\n';\n}\nOutput:
[json.exception.parse_error.101] parse error at line 3, column 9: syntax error while parsing object key - invalid literal; last read: '<U+000A> {<U+000A> /'; expected string literal\n{\n \"planets\": [\n \"Mercury\",\n \"Venus\",\n \"Earth\",\n \"Mars\",\n \"Jupiter\",\n \"Uranus\",\n \"Neptune\"\n ]\n}\nA basic_json value stores JSON data, but most of the time you want to move that data into ordinary C++ types (an int, a std::string, a std::vector, or one of your own structs) and back. This page describes how these conversions work.
The get function template returns a copy of the stored value converted to the requested type:
json j = R\"({\"name\": \"Mary\", \"age\": 42, \"hobbies\": [\"hiking\", \"reading\"]})\"_json;\n\nauto name = j[\"name\"].get<std::string>(); // \"Mary\"\nauto age = j[\"age\"].get<int>(); // 42\nauto hobbies = j[\"hobbies\"].get<std::vector<std::string>>(); // {\"hiking\", \"reading\"}\nGetting a string without quotes
A frequent point of confusion: use get, not dump, to read a string value. j[\"name\"].get<std::string>() yields Mary, whereas j[\"name\"].dump() yields the JSON text \"Mary\" (with quotes), because dump always produces a JSON text.
Alternatively, get_to writes into an existing variable and deduces the target type, which avoids repeating it:
#include <iostream>\n#include <unordered_map>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create a JSON value with different types\n json json_types =\n {\n {\"boolean\", true},\n {\n \"number\", {\n {\"integer\", 42},\n {\"floating-point\", 17.23}\n }\n },\n {\"string\", \"Hello, world!\"},\n {\"array\", {1, 2, 3, 4, 5}},\n {\"null\", nullptr}\n };\n\n bool v1;\n int v2;\n short v3;\n float v4;\n int v5;\n std::string v6;\n std::vector<short> v7;\n std::unordered_map<std::string, json> v8;\n\n // use explicit conversions\n json_types[\"boolean\"].get_to(v1);\n json_types[\"number\"][\"integer\"].get_to(v2);\n json_types[\"number\"][\"integer\"].get_to(v3);\n json_types[\"number\"][\"floating-point\"].get_to(v4);\n json_types[\"number\"][\"floating-point\"].get_to(v5);\n json_types[\"string\"].get_to(v6);\n json_types[\"array\"].get_to(v7);\n json_types.get_to(v8);\n\n // print the conversion results\n std::cout << v1 << '\\n';\n std::cout << v2 << ' ' << v3 << '\\n';\n std::cout << v4 << ' ' << v5 << '\\n';\n std::cout << v6 << '\\n';\n\n for (auto i : v7)\n {\n std::cout << i << ' ';\n }\n std::cout << \"\\n\\n\";\n\n for (auto i : v8)\n {\n std::cout << i.first << \": \" << i.second << '\\n';\n }\n}\nOutput:
1\n42 42\n17.23 17\nHello, world!\n1 2 3 4 5 \n\nstring: \"Hello, world!\"\nnumber: {\"floating-point\":17.23,\"integer\":42}\nnull: null\nboolean: true\narray: [1,2,3,4,5]\nThe library already knows how to convert to and from the scalar types and the STL containers (such as std::vector, std::map, std::array, std::optional, and many more). Converting a JSON object back to a std::map or a JSON array back to a std::vector therefore works without any extra code:
json j = {{\"one\", 1}, {\"two\", 2}};\nauto m = j.get<std::map<std::string, int>>(); // {{\"one\", 1}, {\"two\", 2}}\nBy default, a JSON value implicitly converts to a compatible C++ type, so the explicit get call can often be omitted:
json j = \"Hello\";\nstd::string s = j; // implicit conversion, same as j.get<std::string>()\nImplicit conversions are convenient but can be surprising (for example, in overload resolution or with auto). They can be disabled by defining JSON_USE_IMPLICIT_CONVERSIONS to 0, which forces the explicit get form and can catch unintended conversions at compile time.
Conversions do not range-check numbers
Just like C++ itself, the get family performs numeric conversions without range checks \u2014 retrieving a floating-point value as an integer truncates it, and narrowing conversions may overflow. See number conversion for details and how to guard against it.
The reverse direction works the same way: assigning or constructing a json from a C++ value converts it to JSON.
std::vector<int> numbers = {1, 2, 3};\njson j = numbers; // [1,2,3]\nThe conversions above are built in for standard types. To make the same syntax work for your own types, provide to_json/from_json functions (or use one of the convenience macros). This is described in detail on the arbitrary types conversions page. Enums can be mapped to strings as described in specializing enum conversion.
get - get a copy converted to a given typeget_to - convert into an existing variableget_ref / get_ptr - access the stored value without copyingJSON_USE_IMPLICIT_CONVERSIONS - toggle implicit conversionsThere are several ways to create a JSON value in memory. This page gives an overview; to read a value from JSON text instead, see parsing.
"},{"location":"features/creating_values/#from-c-values","title":"From C++ values","text":"Any value of a supported C++ type can be assigned to or used to construct a json:
json j_number = 42;\njson j_float = 3.141;\njson j_string = \"Hello\";\njson j_boolean = true;\njson j_null = nullptr;\njson j_vector = std::vector<int>{1, 2, 3}; // array\nSee converting values for the full set of supported types.
"},{"location":"features/creating_values/#with-initializer-lists","title":"With initializer lists","text":"Objects and arrays can be written concisely with brace-enclosed initializer lists:
// an array\njson array = {1, 2, 3, 4};\n\n// an object (a list of key/value pairs)\njson object = {\n {\"pi\", 3.141},\n {\"happy\", true},\n {\"name\", \"Niels\"},\n {\"nothing\", nullptr},\n {\"list\", {1, 0, 2}},\n {\"object\", {{\"currency\", \"USD\"}, {\"value\", 42.99}}}\n};\nThe library decides between an array and an object based on the content: a list whose elements are all two-element lists with a string as the first element is treated as an object, everything else as an array.
Ambiguous cases: {} vs. []
Because the same {} syntax is used for both arrays and objects, some cases are ambiguous. To force a particular type, use the explicit factory functions json::array and json::object:
json empty_array_explicit = json::array(); // []\njson empty_object_explicit = json::object(); // {}\n\n// a JSON array with one object, not an object with one member\njson array_of_objects = json::array({{\"key\", \"value\"}}); // [{\"key\":\"value\"}]\nRelated to this, single-element brace initialization such as json j{value}; wraps the element in a single-element array by default, and its behavior even differs between compilers. See the FAQ for details and the opt-in JSON_BRACE_INIT_COPY_SEMANTICS macro.
A value can also be built up piece by piece. Accessing a non-existing object key or array index with operator[] creates the element on the fly:
json j; // null\nj[\"answer\"][\"everything\"] = 42; // becomes an object\nj[\"list\"] = {1, 0, 2};\nj[\"list\"].push_back(3); // [1,0,2,3]\nSee modifying values for push_back, emplace, and related functions.
_json literal","text":"The _json user-defined literal parses a string at the call site and is a convenient way to write a JSON value inline:
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n json j = R\"( {\"hello\": \"world\", \"answer\": 42} )\"_json;\n\n std::cout << std::setw(2) << j << '\\n';\n}\nOutput:
{\n \"answer\": 42,\n \"hello\": \"world\"\n}\nNote this parses the string, so \"42\"_json is the number 42, whereas json(\"42\") is the JSON string \"42\".
basic_json constructors - all ways to construct a valuearray / object - force array or object typeoperator\"\"_json - the _json literalBy default, enum values are serialized to JSON as integers. In some cases, this could result in undesired behavior. If the integer values of any enum values are changed after data using those enum values has been serialized to JSON, then deserializing that JSON would result in a different enum value being restored, or the value not being found at all.
It is possible to more precisely specify how a given enum is mapped to and from JSON as shown below:
// example enum type declaration\nenum TaskState {\n TS_STOPPED,\n TS_RUNNING,\n TS_COMPLETED,\n TS_INVALID=-1,\n};\n\n// map TaskState values to JSON as strings\nNLOHMANN_JSON_SERIALIZE_ENUM( TaskState, {\n {TS_INVALID, nullptr},\n {TS_STOPPED, \"stopped\"},\n {TS_RUNNING, \"running\"},\n {TS_COMPLETED, \"completed\"},\n})\nThe NLOHMANN_JSON_SERIALIZE_ENUM() macro declares a set of to_json() / from_json() functions for type TaskState while avoiding repetition and boilerplate serialization code.
// enum to JSON as string\njson j = TS_STOPPED;\nassert(j == \"stopped\");\n\n// json string to enum\njson j3 = \"running\";\nassert(j3.get<TaskState>() == TS_RUNNING);\n\n// undefined json value to enum (where the first map entry above is the default)\njson jPi = 3.14;\nassert(jPi.get<TaskState>() == TS_INVALID );\nJust as in Arbitrary Type Conversions above,
NLOHMANN_JSON_SERIALIZE_ENUM() MUST be declared in your enum type's namespace (which can be the global namespace), or the library will not be able to locate it, and it will default to integer serialization.Other Important points:
get<ENUM_TYPE>(), undefined JSON values will default to the first pair specified in your map. Select this default pair carefully. If you desire an exception in this circumstance use NLOHMANN_JSON_SERIALIZE_ENUM_STRICT() which behaves identically except for throwing an exception on unrecognized values.JSON_DISABLE_ENUM_SERIALIZATION.A basic_json value is a container and allows access via iterators. Depending on the value type, basic_json stores zero or more values.
As for other containers, begin() returns an iterator to the first value and end() returns an iterator to the value following the last value. The latter iterator is a placeholder and cannot be dereferenced. In case of null values, empty arrays, or empty objects, begin() will return end().
When iterating over objects, values are ordered with respect to the object_comparator_t type which defaults to std::less. See the types documentation for more information.
// create JSON object {\"one\": 1, \"two\": 2, \"three\": 3}\njson j;\nj[\"one\"] = 1;\nj[\"two\"] = 2;\nj[\"three\"] = 3;\n\nfor (auto it = j.begin(); it != j.end(); ++it)\n{\n std::cout << *it << std::endl;\n}\nOutput:
1\n3\n2\nThe reason for the order is the lexicographic ordering of the object keys \"one\", \"three\", \"two\".
"},{"location":"features/iterators/#access-object-keys-during-iteration","title":"Access object keys during iteration","text":"The JSON iterators have two member functions, key() and value() to access the object key and stored value, respectively. When calling key() on a non-object iterator, an invalid_iterator.207 exception is thrown.
// create JSON object {\"one\": 1, \"two\": 2, \"three\": 3}\njson j;\nj[\"one\"] = 1;\nj[\"two\"] = 2;\nj[\"three\"] = 3;\n\nfor (auto it = j.begin(); it != j.end(); ++it)\n{\n std::cout << it.key() << \" : \" << it.value() << std::endl;\n}\nOutput:
one : 1\nthree : 3\ntwo : 2\nC++11 allows using range-based for loops to iterate over a container.
for (auto it : j_object)\n{\n // \"it\" is of type json::reference and has no key() member\n std::cout << \"value: \" << it << '\\n';\n}\nFor this reason, the items() function allows accessing iterator::key() and iterator::value() during range-based for loops. In these loops, a reference to the JSON values is returned, so there is no access to the underlying iterator.
for (auto& el : j_object.items())\n{\n std::cout << \"key: \" << el.key() << \", value:\" << el.value() << '\\n';\n}\nThe items() function also allows using structured bindings (C++17):
for (auto& [key, val] : j_object.items())\n{\n std::cout << \"key: \" << key << \", value:\" << val << '\\n';\n}\nNote
When iterating over an array, key() will return the index of the element as string. For primitive types (e.g., numbers), key() returns an empty string.
Warning
Using items() on temporary objects is dangerous. Make sure the object's lifetime exceeds the iteration. See #2040 for more information.
rbegin() and rend() return iterators in the reverse sequence.
json j = {1, 2, 3, 4};\n\nfor (auto it = j.rbegin(); it != j.rend(); ++it)\n{\n std::cout << *it << std::endl;\n}\nOutput:
4\n3\n2\n1\nNote that \"value\" means a JSON value in this setting, not values stored in the underlying containers. That is, *begin() returns the complete string or binary array and is also safe if the underlying string or binary array is empty.
json j = \"Hello, world\";\nfor (auto it = j.begin(); it != j.end(); ++it)\n{\n std::cout << *it << std::endl;\n}\nOutput:
\"Hello, world\"\nclear all"},{"location":"features/json_patch/","title":"JSON Patch and Diff","text":""},{"location":"features/json_patch/#patches","title":"Patches","text":"JSON Patch (RFC 6902) defines a JSON document structure for expressing a sequence of operations to apply to a JSON document. With the patch function, a JSON Patch is applied to the current JSON value by executing all operations from the patch.
The following code shows how a JSON patch is applied to a value.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // the original document\n json doc = R\"(\n {\n \"baz\": \"qux\",\n \"foo\": \"bar\"\n }\n )\"_json;\n\n // the patch\n json patch = R\"(\n [\n { \"op\": \"replace\", \"path\": \"/baz\", \"value\": \"boo\" },\n { \"op\": \"add\", \"path\": \"/hello\", \"value\": [\"world\"] },\n { \"op\": \"remove\", \"path\": \"/foo\"}\n ]\n )\"_json;\n\n // apply the patch\n json patched_doc = doc.patch(patch);\n\n // output original and patched document\n std::cout << std::setw(4) << doc << \"\\n\\n\"\n << std::setw(4) << patched_doc << std::endl;\n}\nOutput:
{\n \"baz\": \"qux\",\n \"foo\": \"bar\"\n}\n\n{\n \"baz\": \"boo\",\n \"hello\": [\n \"world\"\n ]\n}\nThe library can also calculate a JSON patch (i.e., a diff) given two JSON values.
Invariant
For two JSON values source and target, the following code yields always true:
source.patch(diff(source, target)) == target;\nThe following code shows how a JSON patch is created as a diff for two JSON values.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // the source document\n json source = R\"(\n {\n \"baz\": \"qux\",\n \"foo\": \"bar\"\n }\n )\"_json;\n\n // the target document\n json target = R\"(\n {\n \"baz\": \"boo\",\n \"hello\": [\n \"world\"\n ]\n }\n )\"_json;\n\n // create the patch\n json patch = json::diff(source, target);\n\n // roundtrip\n json patched_source = source.patch(patch);\n\n // output patch and roundtrip result\n std::cout << std::setw(4) << patch << \"\\n\\n\"\n << std::setw(4) << patched_source << std::endl;\n}\nOutput:
[\n {\n \"op\": \"replace\",\n \"path\": \"/baz\",\n \"value\": \"boo\"\n },\n {\n \"op\": \"remove\",\n \"path\": \"/foo\"\n },\n {\n \"op\": \"add\",\n \"path\": \"/hello\",\n \"value\": [\n \"world\"\n ]\n }\n]\n\n{\n \"baz\": \"boo\",\n \"hello\": [\n \"world\"\n ]\n}\nThe library supports JSON Pointer (RFC 6901) as an alternative means to address structured values. A JSON Pointer is a string that identifies a specific value within a JSON document.
Consider the following JSON document
{\n \"array\": [\"A\", \"B\", \"C\"],\n \"nested\": {\n \"one\": 1,\n \"two\": 2,\n \"three\": [true, false]\n }\n}\nThen every value inside the JSON document can be identified as follows:
JSON Pointer JSON value ``{\"array\":[\"A\",\"B\",\"C\"],\"nested\":{\"one\":1,\"two\":2,\"three\":[true,false]}} /array [\"A\",\"B\",\"C\"] /array/0 A /array/1 B /array/2 C /nested {\"one\":1,\"two\":2,\"three\":[true,false]} /nested/one 1 /nested/two 2 /nested/three [true,false] /nested/three/0 true /nested/three/1 false Note / does not identify the root (i.e., the whole document), but an object entry with empty key \"\". See RFC 6901 for more information.
JSON Pointers can be created from a string:
json::json_pointer p(\"/nested/one\");\nFurthermore, a user-defined string literal can be used to achieve the same result:
auto p = \"/nested/one\"_json_pointer;\nThe escaping rules of RFC 6901 are implemented. See the constructor documentation for more information.
"},{"location":"features/json_pointer/#value-access","title":"Value access","text":"JSON Pointers can be used in the at, operator[], and value functions just like object keys or array indices.
// the JSON value from above\nauto j = json::parse(R\"({\n \"array\": [\"A\", \"B\", \"C\"],\n \"nested\": {\n \"one\": 1,\n \"two\": 2,\n \"three\": [true, false]\n }\n})\");\n\n// access values\nauto val = j[\"\"_json_pointer]; // {\"array\":[\"A\",\"B\",\"C\"],...}\nauto val1 = j[\"/nested/one\"_json_pointer]; // 1\nauto val2 = j.at(json::json_pointer(\"/nested/three/1\")); // false\nauto val3 = j.value(json::json_pointer(\"/nested/four\"), 0); // 0\nThe library implements a function flatten to convert any JSON document into a JSON object where each key is a JSON Pointer and each value is a primitive JSON value (i.e., a string, boolean, number, or null).
// the JSON value from above\nauto j = json::parse(R\"({\n \"array\": [\"A\", \"B\", \"C\"],\n \"nested\": {\n \"one\": 1,\n \"two\": 2,\n \"three\": [true, false]\n }\n})\");\n\n// create flattened value\nauto j_flat = j.flatten();\nThe resulting value j_flat is:
{\n \"/array/0\": \"A\",\n \"/array/1\": \"B\",\n \"/array/2\": \"C\",\n \"/nested/one\": 1,\n \"/nested/two\": 2,\n \"/nested/three/0\": true,\n \"/nested/three/1\": false\n}\nThe reverse function, unflatten recreates the original value.
auto j_original = j_flat.unflatten();\njson_pointerflattenunflattenSome aspects of the library can be configured by defining preprocessor macros before including the json.hpp header. See also the API documentation for macros for examples and more information.
JSON_ASSERT(x)","text":"This macro controls which code is executed for runtime assertions of the library.
See full documentation of JSON_ASSERT(x).
JSON_BRACE_INIT_COPY_SEMANTICS","text":"When defined to 1, single-element brace initialization of a basic_json value (e.g., json j{value};) is treated as a copy/move of the element rather than wrapping it in a single-element array. The default value is 0, which preserves the existing behavior.
See full documentation of JSON_BRACE_INIT_COPY_SEMANTICS.
JSON_CATCH_USER(exception)","text":"This macro overrides catch calls inside the library.
See full documentation of JSON_CATCH_USER(exception).
JSON_DIAGNOSTICS","text":"This macro enables extended diagnostics for exception messages. Possible values are 1 to enable or 0 to disable (default).
When enabled, exception messages contain a JSON Pointer to the JSON value that triggered the exception, see Extended diagnostic messages for an example. Note that enabling this macro increases the size of every JSON value by one pointer and adds some runtime overhead.
The diagnostics messages can also be controlled with the CMake option JSON_Diagnostics (OFF by default) which sets JSON_DIAGNOSTICS accordingly.
See full documentation of JSON_DIAGNOSTICS.
JSON_DIAGNOSTIC_POSITIONS","text":"When enabled, two new member functions start_pos() and end_pos() are added to basic_json values. If the value was created by calling theparse function, then these functions allow querying the byte positions of the value in the input it was parsed from. The byte positions are also used in exceptions to help locate errors.
The diagnostics positions can also be controlled with the CMake option JSON_Diagnostic_Positions (OFF by default) which sets JSON_DIAGNOSTIC_POSITIONS accordingly.
See full documentation of JSON_DIAGNOSTIC_POSITIONS
JSON_HAS_CPP_11, JSON_HAS_CPP_14, JSON_HAS_CPP_17, JSON_HAS_CPP_20, JSON_HAS_CPP_23, JSON_HAS_CPP_26","text":"The library targets C++11, but also supports some features introduced in later C++ versions (e.g., std::string_view support for C++17). For these new features, the library implements some preprocessor checks to determine the C++ standard. By defining any of these symbols, the internal check is overridden and the provided C++ version is unconditionally assumed. This can be helpful for compilers that only implement parts of the standard and would be detected incorrectly.
See full documentation of JSON_HAS_CPP_11, JSON_HAS_CPP_14, JSON_HAS_CPP_17, JSON_HAS_CPP_20, JSON_HAS_CPP_23, and JSON_HAS_CPP_26.
JSON_HAS_FILESYSTEM, JSON_HAS_EXPERIMENTAL_FILESYSTEM","text":"When compiling with C++17, the library provides conversions from and to std::filesystem::path. As compiler support for filesystem is limited, the library tries to detect whether <filesystem>/std::filesystem (JSON_HAS_FILESYSTEM) or <experimental/filesystem>/std::experimental::filesystem (JSON_HAS_EXPERIMENTAL_FILESYSTEM) should be used. To override the built-in check, define JSON_HAS_FILESYSTEM or JSON_HAS_EXPERIMENTAL_FILESYSTEM to 1.
See full documentation of JSON_HAS_FILESYSTEM and JSON_HAS_EXPERIMENTAL_FILESYSTEM.
JSON_NOEXCEPTION","text":"Exceptions can be switched off by defining the symbol JSON_NOEXCEPTION.
See full documentation of JSON_NOEXCEPTION.
JSON_DISABLE_ENUM_SERIALIZATION","text":"When defined, default parse and serialize functions for enums are excluded and have to be provided by the user, for example, using NLOHMANN_JSON_SERIALIZE_ENUM.
See full documentation of JSON_DISABLE_ENUM_SERIALIZATION.
JSON_NO_IO","text":"When defined, headers <cstdio>, <ios>, <iosfwd>, <istream>, and <ostream> are not included and parse functions relying on these headers are excluded. This is relevant for environment where these I/O functions are disallowed for security reasons (e.g., Intel Software Guard Extensions (SGX)).
See full documentation of JSON_NO_IO.
JSON_SKIP_LIBRARY_VERSION_CHECK","text":"When defined, the library will not create a compiler warning when a different version of the library was already included.
See full documentation of JSON_SKIP_LIBRARY_VERSION_CHECK.
JSON_SKIP_UNSUPPORTED_COMPILER_CHECK","text":"When defined, the library will not create a compile error when a known unsupported compiler is detected. This allows using the library with compilers that do not fully support C++11 and may only work if unsupported features are not used.
See full documentation of JSON_SKIP_UNSUPPORTED_COMPILER_CHECK.
JSON_THROW_USER(exception)","text":"This macro overrides throw calls inside the library. The argument is the exception to be thrown.
See full documentation of JSON_THROW_USER(exception).
JSON_TRY_USER","text":"This macro overrides try calls inside the library.
See full documentation of JSON_TRY_USER.
JSON_USE_IMPLICIT_CONVERSIONS","text":"When defined to 0, implicit conversions are switched off. By default, implicit conversions are switched on.
See full documentation of JSON_USE_IMPLICIT_CONVERSIONS.
JSON_USE_GLOBAL_UDLS","text":"When defined to 1 (default), the user-defined string literals operator\"\"_json and operator\"\"_json_pointer are placed into the global namespace instead of nlohmann::literals::json_literals.
See full documentation of JSON_USE_GLOBAL_UDLS.
JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON","text":"When defined to 1, the library restores the legacy behavior in which a discarded value compared equal to itself. This behavior is deprecated and switched off (0) by default.
See full documentation of JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON.
NLOHMANN_DEFINE_TYPE_*(...), NLOHMANN_DEFINE_DERIVED_TYPE_*(...)","text":"The library defines 12 macros to simplify the serialization/deserialization of types. See the page on arbitrary type conversion for a detailed discussion.
"},{"location":"features/macros/#nlohmann_json_namespace-nlohmann_json_namespace_begin-nlohmann_json_namespace_end-nlohmann_json_namespace_no_version","title":"NLOHMANN_JSON_NAMESPACE, NLOHMANN_JSON_NAMESPACE_BEGIN, NLOHMANN_JSON_NAMESPACE_END, NLOHMANN_JSON_NAMESPACE_NO_VERSION","text":"These macros relate to the versioned, inline nlohmann namespace:
NLOHMANN_JSON_NAMESPACE evaluates to the full name of the nlohmann namespace (including the inline ABI namespace).NLOHMANN_JSON_NAMESPACE_BEGIN / NLOHMANN_JSON_NAMESPACE_END open and close the namespace (for example, to add specializations).NLOHMANN_JSON_NAMESPACE_NO_VERSION, when defined to 1, omits the version component from the inline namespace.See the nlohmann Namespace page, and the full documentation of NLOHMANN_JSON_NAMESPACE, NLOHMANN_JSON_NAMESPACE_BEGIN / NLOHMANN_JSON_NAMESPACE_END, and NLOHMANN_JSON_NAMESPACE_NO_VERSION.
NLOHMANN_JSON_SERIALIZE_ENUM(type, ...)","text":"This macro simplifies the serialization/deserialization of enum types. See Specializing enum conversion for more information.
See full documentation of NLOHMANN_JSON_SERIALIZE_ENUM.
A strict variant NLOHMANN_JSON_SERIALIZE_ENUM_STRICT throws an exception on undefined input instead of falling back to the first mapping.
NLOHMANN_JSON_VERSION_MAJOR, NLOHMANN_JSON_VERSION_MINOR, NLOHMANN_JSON_VERSION_PATCH","text":"These macros are defined by the library and contain the version numbers according to Semantic Versioning 2.0.0.
See full documentation of NLOHMANN_JSON_VERSION_MAJOR, NLOHMANN_JSON_VERSION_MINOR, and NLOHMANN_JSON_VERSION_PATCH.
The library supports JSON Merge Patch (RFC 7386) as a patch format. The merge patch format is primarily intended for use with the HTTP PATCH method as a means of describing a set of modifications to a target resource's content. This function applies a merge patch to the current JSON value.
Instead of using JSON Pointer to specify values to be manipulated, it describes the changes using a syntax that closely mimics the document being modified.
ExampleThe following code shows how a JSON Merge Patch is applied to a JSON document.
#include <iostream>\n#include <nlohmann/json.hpp>\n#include <iomanip> // for std::setw\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // the original document\n json document = R\"({\n \"title\": \"Goodbye!\",\n \"author\": {\n \"givenName\": \"John\",\n \"familyName\": \"Doe\"\n },\n \"tags\": [\n \"example\",\n \"sample\"\n ],\n \"content\": \"This will be unchanged\"\n })\"_json;\n\n // the patch\n json patch = R\"({\n \"title\": \"Hello!\",\n \"phoneNumber\": \"+01-123-456-7890\",\n \"author\": {\n \"familyName\": null\n },\n \"tags\": [\n \"example\"\n ]\n })\"_json;\n\n // apply the patch\n document.merge_patch(patch);\n\n // output original and patched document\n std::cout << std::setw(4) << document << std::endl;\n}\nOutput:
{\n \"author\": {\n \"givenName\": \"John\"\n },\n \"content\": \"This will be unchanged\",\n \"phoneNumber\": \"+01-123-456-7890\",\n \"tags\": [\n \"example\"\n ],\n \"title\": \"Hello!\"\n}\nOnce a JSON value exists, its content can be changed: elements can be added, replaced, merged, and removed. This page gives an overview of the available operations. For read access, see element access.
"},{"location":"features/modifying_values/#adding-to-arrays","title":"Adding to arrays","text":"New elements are appended to an array with push_back or constructed in place with emplace_back. If the value is null, it is converted to an array first, so these functions can also be used to build an array from scratch.
json j; // null\nj.push_back(1); // [1]\nj.push_back(2); // [1,2]\nj.emplace_back(3); // [1,2,3]\n\n// operator+= is a shorthand for push_back\nj += 4; // [1,2,3,4]\nThe most common way to add or replace a member is operator[], which inserts the key if it does not exist yet:
json j;\nj[\"name\"] = \"Mary\"; // {\"name\":\"Mary\"}\nj[\"name\"] = \"John\"; // {\"name\":\"John\"} (replaced)\nemplace inserts a member only if the key is not already present, and reports whether the insertion happened \u2014 useful for \"add if absent\" semantics.
To merge one object into another, update copies all members from another object, overwriting existing keys (similar to Python's dict.update). This is the idiomatic way to combine two objects.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create two JSON objects\n json o1 = R\"( {\"color\": \"red\", \"price\": 17.99, \"names\": {\"de\": \"Flugzeug\"}} )\"_json;\n json o2 = R\"( {\"color\": \"blue\", \"speed\": 100, \"names\": {\"en\": \"plane\"}} )\"_json;\n json o3 = o1;\n\n // add all keys from o2 to o1 (updating \"color\", replacing \"names\")\n o1.update(o2);\n\n // add all keys from o2 to o1 (updating \"color\", merging \"names\")\n o3.update(o2, true);\n\n // output updated object o1 and o3\n std::cout << std::setw(2) << o1 << '\\n';\n std::cout << std::setw(2) << o3 << '\\n';\n}\nOutput:
{\n \"color\": \"blue\",\n \"names\": {\n \"en\": \"plane\"\n },\n \"price\": 17.99,\n \"speed\": 100\n}\n{\n \"color\": \"blue\",\n \"names\": {\n \"de\": \"Flugzeug\",\n \"en\": \"plane\"\n },\n \"price\": 17.99,\n \"speed\": 100\n}\nFor a recursive merge that follows RFC 7386, see JSON Merge Patch. To apply a sequence of well-defined edit operations, see JSON Patch.
"},{"location":"features/modifying_values/#removing-elements","title":"Removing elements","text":"Elements are removed with erase, which accepts an object key, an array index, or an iterator. clear empties a value while keeping its type, and operator[] combined with assignment can overwrite a value entirely.
json j = {{\"a\", 1}, {\"b\", 2}, {\"c\", 3}};\nj.erase(\"b\"); // {\"a\":1,\"c\":3}\n\njson a = {1, 2, 3, 4};\na.erase(1); // [1,3,4] (erase by index)\npush_back / emplace_back - append to an arrayemplace - insert into an object if the key is absentupdate - merge objectserase / clear - remove elementsThis library has experimental support for C++ modules, introduced in C++20. The library can be imported by writing import nlohmann.json; instead of #include <nlohmann/json.hpp>.
Please be aware that the module is experimental and a full test is outstanding, and the exported symbols are subject to change.
"},{"location":"features/modules/#requirements","title":"Requirements","text":"The nlohmann.json module requires that the build system is configured to build and resolve modules when imported. Obviously, as modules were introduced in C++20, this feature can only be used in C++20 and subsequent versions.
To enable building the nlohmann.json module (which is not done by default), the macro NLOHMANN_JSON_BUILD_MODULES must be passed to the build system.
When using modules rather than headers, the previous example for creating a json object through a JSON file, would instead be:
import std;\nimport nlohmann.json;\n\nusing json = nlohmann::json;\n\n// ...\n\nstd::ifstream f(\"example.json\");\njson data = json::parse(f);\nIt should be noted that as modules do not export macros, the nlohmann.json module will not export any macros.
Only the following symbols are exported from nlohmann.json:
nlohmann::adl_serializernlohmann::basic_jsonnlohmann::jsonnlohmann::json_pointernlohmann::ordered_jsonnlohmann::ordered_mapnlohmann::to_stringnlohmann::literals::json_literals::operator\"\"_jsonnlohmann::literals::json_literals::operator\"\"_json_pointernlohmann Namespace","text":"The 3.11.0 release introduced an inline namespace to allow different parts of a codebase to safely use different versions of the JSON library as long as they never exchange instances of library types.
"},{"location":"features/namespace/#structure","title":"Structure","text":"The complete default namespace name is derived as follows:
nlohmann.json_abi and is followed by several optional ABI tags according to the value of these ABI-affecting macros, in order:JSON_DIAGNOSTICS defined non-zero appends _diag.JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON defined non-zero appends _ldvcmp._v followed by the 3 components of the version number separated by underscores. To omit the version component, see Disabling the version component below.For example, the namespace name for version 3.11.2 with JSON_DIAGNOSTICS defined to 1 is:
nlohmann::json_abi_diag_v3_11_2\nSeveral incompatibilities have been observed. Amongst the most common ones is linking code compiled with different definitions of JSON_DIAGNOSTICS. This is illustrated in the diagram below.
graph\n json[\"<strong>nlohmann_json (v3.10.5)</strong><br>JSON_DIAGNOSTICS=0\"]\n json_diag[\"<strong>nlohmann_json (v3.10.5)</strong><br>JSON_DIAGNOSTICS=1\"]\n library[\"<strong>some library</strong>\"]\n app[\"<strong>application</strong>\"]\n\n library --> json\n app --> json_diag\n app --> libraryIn releases prior to 3.11.0, mixing any version of the JSON library with different JSON_DIAGNOSTICS settings would result in a crashing application. If some_library never passes instances of JSON library types to the application, this scenario became safe in version 3.11.0 and above due to the inline namespace yielding distinct symbol names.
Neither the compiler nor the linker will issue as much as a warning when translation units \u2013 intended to be linked together and that include different versions and/or configurations of the JSON library \u2013 exchange and use library types.
There is an exception when forward declarations are used (i.e., when including json_fwd.hpp) in which case the linker may complain about undefined references.
Different versions are not necessarily ABI-incompatible, but the project does not actively track changes in the ABI and recommends that all parts of a codebase exchanging library types be built with the same version. Users can, at their own risk, disable the version component of the inline namespace, allowing different versions \u2013 but not configurations \u2013 to be used in cases where the linker would otherwise output undefined reference errors.
To do so, define NLOHMANN_JSON_NAMESPACE_NO_VERSION to 1.
This applies to version 3.11.2 and above only; versions 3.11.0 and 3.11.1 can apply the technique described in the next section to emulate the effect of the NLOHMANN_JSON_NAMESPACE_NO_VERSION macro.
Use at your own risk
Disabling the namespace version component and mixing ABI-incompatible versions will result in crashes or incorrect behavior. You have been warned!
"},{"location":"features/namespace/#disabling-the-inline-namespace-completely","title":"Disabling the inline namespace completely","text":"When interoperability with code using a pre-3.11.0 version of the library is required, users can, at their own risk restore the old namespace layout by redefining NLOHMANN_JSON_NAMESPACE_BEGIN, NLOHMANN_JSON_NAMESPACE_END as follows:
#define NLOHMANN_JSON_NAMESPACE_BEGIN namespace nlohmann {\n#define NLOHMANN_JSON_NAMESPACE_END }\nUse at your own risk
Overriding the namespace and mixing ABI-incompatible versions will result in crashes or incorrect behavior. You have been warned!
"},{"location":"features/namespace/#version-history","title":"Version history","text":"json_v3_11_0[_abi-tag]*) in version 3.11.0.The JSON standard defines objects as \"an unordered collection of zero or more name/value pairs\". As such, an implementation does not need to preserve any specific order of object keys.
"},{"location":"features/object_order/#default-behavior-sort-keys","title":"Default behavior: sort keys","text":"The default type nlohmann::json uses a std::map to store JSON objects, and thus stores object keys sorted alphabetically.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j;\n j[\"one\"] = 1;\n j[\"two\"] = 2;\n j[\"three\"] = 3;\n\n std::cout << j.dump(2) << '\\n';\n}\nOutput:
{\n \"one\": 1,\n \"three\": 3,\n \"two\": 2\n}\nIf you do want to preserve the insertion order, you can use the type nlohmann::ordered_json.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing ordered_json = nlohmann::ordered_json;\n\nint main()\n{\n ordered_json j;\n j[\"one\"] = 1;\n j[\"two\"] = 2;\n j[\"three\"] = 3;\n\n std::cout << j.dump(2) << '\\n';\n}\nOutput:
{\n \"one\": 1,\n \"two\": 2,\n \"three\": 3\n}\nAlternatively, you can use a more sophisticated ordered map like tsl::ordered_map (integration) or nlohmann::fifo_map (integration).
Note that you also need to call the right parse function when reading from a file. Assume file input.json contains the JSON object above:
{\n \"one\": 1,\n \"two\": 2,\n \"three\": 3\n}\nRight way
The following code correctly calls the parse function from nlohmann::ordered_json:
std::ifstream i(\"input.json\");\nauto j = nlohmann::ordered_json::parse(i);\nstd::cout << j.dump(2) << std::endl;\nThe output will be:
{\n \"one\": 1,\n \"two\": 2,\n \"three\": 3\n}\nThe following code incorrectly calls the parse function from nlohmann::json which does not preserve the insertion order, but sorts object keys. Assigning the result to nlohmann::ordered_json compiles, but does not restore the order from the input file.
std::ifstream i(\"input.json\");\nnlohmann::ordered_json j = nlohmann::json::parse(i);\nstd::cout << j.dump(2) << std::endl;\nThe output will be:
{\n \"one\": 1,\n \"three\": 3,\n \"two\": 2\n}\nSerialization is the process of turning a JSON value back into JSON text. It is the counterpart to parsing. The central function is dump, which returns the JSON text as a string.
json j = {{\"pi\", 3.141}, {\"happy\", true}};\n\nstd::string s = j.dump(); // {\"happy\":true,\"pi\":3.141}\nTo write a value directly to a stream (for example, a file or std::cout), the operator<< is provided:
std::cout << j << std::endl;\nString, not raw value
dump always returns a JSON text. Serializing a JSON string therefore includes the surrounding quotes and escapes special characters. To obtain the contained string value without quotes, use get<std::string>() instead of dump. See the converting values page.
By default, dump produces the most compact representation without any superfluous whitespace. Passing a non-negative indent argument pretty-prints the output with the given number of spaces per level:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON values\n json j_object = {{\"one\", 1}, {\"two\", 2}};\n json j_array = {1, 2, 4, 8, 16};\n json j_string = \"Hell\u00f6 \ud83d\ude00!\";\n\n // call dump()\n std::cout << \"objects:\" << '\\n'\n << j_object.dump() << \"\\n\\n\"\n << j_object.dump(-1) << \"\\n\\n\"\n << j_object.dump(0) << \"\\n\\n\"\n << j_object.dump(4) << \"\\n\\n\"\n << j_object.dump(1, '\\t') << \"\\n\\n\";\n\n std::cout << \"arrays:\" << '\\n'\n << j_array.dump() << \"\\n\\n\"\n << j_array.dump(-1) << \"\\n\\n\"\n << j_array.dump(0) << \"\\n\\n\"\n << j_array.dump(4) << \"\\n\\n\"\n << j_array.dump(1, '\\t') << \"\\n\\n\";\n\n std::cout << \"strings:\" << '\\n'\n << j_string.dump() << '\\n'\n << j_string.dump(-1, ' ', true) << '\\n';\n\n // create JSON value with invalid UTF-8 byte sequence\n json j_invalid = \"\u00e4\\xA9\u00fc\";\n try\n {\n std::cout << j_invalid.dump() << std::endl;\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n std::cout << \"string with replaced invalid characters: \"\n << j_invalid.dump(-1, ' ', false, json::error_handler_t::replace)\n << \"\\nstring with ignored invalid characters: \"\n << j_invalid.dump(-1, ' ', false, json::error_handler_t::ignore)\n << '\\n';\n}\nOutput:
objects:\n{\"one\":1,\"two\":2}\n\n{\"one\":1,\"two\":2}\n\n{\n\"one\": 1,\n\"two\": 2\n}\n\n{\n \"one\": 1,\n \"two\": 2\n}\n\n{\n \"one\": 1,\n \"two\": 2\n}\n\narrays:\n[1,2,4,8,16]\n\n[1,2,4,8,16]\n\n[\n1,\n2,\n4,\n8,\n16\n]\n\n[\n 1,\n 2,\n 4,\n 8,\n 16\n]\n\n[\n 1,\n 2,\n 4,\n 8,\n 16\n]\n\nstrings:\n\"Hell\u00f6 \ud83d\ude00!\"\n\"Hell\\u00f6 \\ud83d\\ude00!\"\n[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9\nstring with replaced invalid characters: \"\u00e4\ufffd\u00fc\"\nstring with ignored invalid characters: \"\u00e4\u00fc\"\nThe indentation character can be changed with the second argument (e.g., a tab '\\t'). An indent of 0 inserts newlines but no leading spaces, and the default of -1 selects the compact single-line form.
Strings are stored and serialized as UTF-8 (see types). By default, dump copies valid non-ASCII characters as-is. Setting the third argument ensure_ascii to true escapes all non-ASCII characters with \\uXXXX sequences, so that the output contains only ASCII characters:
json j = \"\u82f9\u679c\";\nj.dump(); // \"\u82f9\u679c\"\nj.dump(-1, ' ', true); // \"\u82f9\u679c\"\nIf a string contains invalid UTF-8 sequences (for example, because it holds data in another encoding such as Latin-1), serialization fails by default. The fourth argument of dump selects an error_handler:
strict (default) \u2014 throw a type_error.316 exception.replace \u2014 replace invalid bytes with the Unicode replacement character U+FFFD (\ufffd).ignore \u2014 silently drop invalid bytes.#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create JSON value with invalid UTF-8 byte sequence\n json j_invalid = \"\u00e4\\xA9\u00fc\";\n try\n {\n std::cout << j_invalid.dump() << std::endl;\n }\n catch (const json::type_error& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n std::cout << \"string with replaced invalid characters: \"\n << j_invalid.dump(-1, ' ', false, json::error_handler_t::replace)\n << \"\\nstring with ignored invalid characters: \"\n << j_invalid.dump(-1, ' ', false, json::error_handler_t::ignore)\n << '\\n';\n}\nOutput:
[json.exception.type_error.316] invalid UTF-8 byte at index 2: 0xA9\nstring with replaced invalid characters: \"\u00e4\ufffd\u00fc\"\nstring with ignored invalid characters: \"\u00e4\u00fc\"\nAvoiding invalid UTF-8
The best fix is to ensure that all strings are UTF-8 encoded before storing them. See the FAQ on non-ASCII characters for how to convert wide or Latin-1 strings.
"},{"location":"features/serialization/#numbers-nan-and-binary-values","title":"Numbers, NaN, and binary values","text":"null; see NaN handling. The binary formats can preserve them.std::format, std::print, and fmt","text":"Since version 3.12.0, JSON values can be formatted directly with C++20's std::format whenever the standard library provides the <format> header (controlled by JSON_HAS_STD_FORMAT). This is enabled by the std::formatter<basic_json> specialization, which also makes JSON values work with std::format_to and with C++23's std::print/std::println:
std::print(\"{}\", j); // compact, like j.dump()\nstd::print(\"{:2}\", j); // pretty-printed with indent 2 (like j.dump(2))\nstd::println(\"{:#}\", j); // pretty-printed with the default indent\nThe format spec mirrors the dump parameters: \"{:#}\" pretty-prints, a width such as \"{:2}\" sets the indent, and a fill-and-align prefix such as \"{:.>#}\" sets the indent character.
For the {fmt} library, the library ships a format_as helper. Note its behavior depends on the fmt version; see the FAQ entry for the details and a recipe for a full fmt::formatter specialization.
Besides JSON text, a value can also be serialized to the more compact binary formats (BJData, BSON, CBOR, MessagePack, UBJSON).
"},{"location":"features/serialization/#see-also","title":"See also","text":"dump - serialize to a JSON-formatted stringoperator<< - serialize to a streamto_string - user-defined-conversion helperstd::formatter<basic_json> - use JSON values with std::format and std::printformat_as - use JSON values with the {fmt} libraryLike comments, this library does not support trailing commas in arrays and objects by default.
You can set parameter ignore_trailing_commas to true in the parse function to allow trailing commas in arrays and objects. Note that a single comma as the only content of the array or object ([,] or {,}) is not allowed, and multiple trailing commas ([1,,]) are not allowed either.
This library does not add trailing commas when serializing JSON data.
For more information, see JSON With Commas and Comments (JWCC).
Example
Consider the following JSON with trailing commas.
{\n \"planets\": [\n \"Mercury\",\n \"Venus\",\n \"Earth\",\n \"Mars\",\n \"Jupiter\",\n \"Uranus\",\n \"Neptune\",\n ]\n}\nWhen calling parse without additional argument, a parse error exception is thrown. If ignore_trailing_commas is set to true, the trailing commas are ignored during parsing:
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::string s = R\"(\n {\n \"planets\": [\n \"Mercury\",\n \"Venus\",\n \"Earth\",\n \"Mars\",\n \"Jupiter\",\n \"Uranus\",\n \"Neptune\",\n ]\n }\n )\";\n\n try\n {\n json j = json::parse(s);\n }\n catch (json::exception& e)\n {\n std::cout << e.what() << std::endl;\n }\n\n json j = json::parse(s,\n /* callback */ nullptr,\n /* allow exceptions */ true,\n /* ignore_comments */ false,\n /* ignore_trailing_commas */ true);\n std::cout << j.dump(2) << '\\n';\n}\nOutput:
[json.exception.parse_error.101] parse error at line 11, column 9: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal\n{\n \"planets\": [\n \"Mercury\",\n \"Venus\",\n \"Earth\",\n \"Mars\",\n \"Jupiter\",\n \"Uranus\",\n \"Neptune\"\n ]\n}\nThough JSON is a ubiquitous data format, it is not a very compact format suitable for data exchange, for instance, over a network. Hence, the library supports
to efficiently encode JSON values to byte vectors and to decode such vectors.
"},{"location":"features/binary_formats/#comparison","title":"Comparison","text":""},{"location":"features/binary_formats/#completeness","title":"Completeness","text":"Format Serialization Deserialization BJData complete complete BSON incomplete: top-level value must be an object incomplete, but all JSON types are supported CBOR complete incomplete, but all JSON types are supported MessagePack complete complete UBJSON complete complete"},{"location":"features/binary_formats/#binary-values","title":"Binary values","text":"Format Binary values Binary subtypes BJData not supported not supported BSON supported supported CBOR supported supported MessagePack supported supported UBJSON not supported not supportedSee binary values for more information.
"},{"location":"features/binary_formats/#sizes","title":"Sizes","text":"Format canada.json twitter.json citm_catalog.json jeopardy.json BJData 53.2 % 91.1 % 78.1 % 96.6 % BJData (size) 58.6 % 92.1 % 86.7 % 97.4 % BJData (size+type) 58.6 % 92.1 % 86.5 % 97.4 % BSON 85.8 % 95.2 % 95.8 % 106.7 % CBOR 50.5 % 86.3 % 68.4 % 88.0 % MessagePack 50.5 % 86.0 % 68.5 % 87.9 % UBJSON 53.2 % 91.3 % 78.2 % 96.6 % UBJSON (size) 58.6 % 92.3 % 86.8 % 97.4 % UBJSON (size+type) 55.9 % 92.3 % 85.0 % 95.0 %Sizes compared to minified JSON value.
"},{"location":"features/binary_formats/bjdata/","title":"BJData","text":"The BJData format was derived from and improved upon Universal Binary JSON(UBJSON) specification (Draft 12). Specifically, it introduces an optimized array container for efficient storage of N-dimensional packed arrays (ND-arrays); it also adds 5 new type markers - [u] - uint16, [m] - uint32, [M] - uint64, [h] - float16 and [B] - byte - to unambiguously map common binary numeric types; furthermore, it uses little-endian (LE) to store all numerics instead of big-endian (BE) as in UBJSON to avoid unnecessary conversions on commonly available platforms.
Compared to other binary JSON-like formats such as MessagePack and CBOR, both BJData and UBJSON demonstrate a rare combination of being both binary and quasi-human-readable. This is because all semantic elements in BJData and UBJSON, including the data-type markers and name/string types, are directly human-readable. Data stored in the BJData/UBJSON format is not only compact in size, fast to read/write, but also can be directly searched or read using simple processing.
References
The library uses the following mapping from JSON values types to BJData types according to the BJData specification:
JSON value type value/range BJData type marker nullnull null Z boolean true true T boolean false false F number_integer -9223372036854775808..-2147483649 int64 L number_integer -2147483648..-32769 int32 l number_integer -32768..-129 int16 I number_integer -128..127 int8 i number_integer 128..255 uint8 U number_integer 256..32767 int16 I number_integer 32768..65535 uint16 u number_integer 65536..2147483647 int32 l number_integer 2147483648..4294967295 uint32 m number_integer 4294967296..9223372036854775807 int64 L number_integer 9223372036854775808..18446744073709551615 uint64 M number_unsigned 0..127 int8 i number_unsigned 128..255 uint8 U number_unsigned 256..32767 int16 I number_unsigned 32768..65535 uint16 u number_unsigned 65536..2147483647 int32 l number_unsigned 2147483648..4294967295 uint32 m number_unsigned 4294967296..9223372036854775807 int64 L number_unsigned 9223372036854775808..18446744073709551615 uint64 M number_float any value float64 D string with shortest length indicator string S array see notes on optimized format/ND-array array [ object see notes on optimized format map { binary see notes on binary values array [$B Complete mapping
The mapping is complete in the sense that any JSON value type can be converted to a BJData value.
Any BJData output created by to_bjdata can be successfully parsed by from_bjdata.
Size constraints
The following values can not be converted to a BJData value:
Unused BJData markers
The following markers are not used in the conversion:
Z: no-op values are not created.C: single-byte strings are serialized with S markers.NaN/infinity handling
If NaN or Infinity are stored inside a JSON number, they are serialized properly. This behavior differs from the dump() function which serializes NaN or Infinity to null.
Endianness
A breaking difference between BJData and UBJSON is the endianness of numerical values. In BJData, all numerical data types (integers UiuImlML and floating-point values hdD) are stored in the little-endian (LE) byte order as opposed to big-endian as used by UBJSON. Adopting LE to store numeric records avoids unnecessary byte swapping on most modern computers where LE is used as the default byte order.
Optimized formats
Optimized formats for containers are supported via two parameters of to_bjdata:
use_size adds size information to the beginning of a container and removes the closing marker.use_type further checks whether all elements of a container have the same type and adds the type marker to the beginning of the container. The use_type parameter must only be used together with use_size = true.Note that use_size = true alone may result in larger representations - the benefit of this parameter is that the receiving side is immediately informed of the number of elements in the container.
ND-array optimized format
BJData extends UBJSON's optimized array size marker to support ND-arrays of uniform numerical data types (referred to as packed arrays). For example, the 2-D uint8 integer array [[1,2],[3,4],[5,6]], stored as nested optimized array in UBJSON [ [$U#i2 1 2 [$U#i2 3 4 [$U#i2 5 6 ], can be further compressed in BJData to [$U#[$i#i2 2 3 1 2 3 4 5 6 or [$U#[i2 i3] 1 2 3 4 5 6.
To maintain type and size information, ND-arrays are converted to JSON objects following the annotated array format (defined in the JData specification (Draft 3)), when parsed using from_bjdata. For example, the above 2-D uint8 array can be parsed and accessed as
{\n \"_ArrayType_\": \"uint8\",\n \"_ArraySize_\": [2,3],\n \"_ArrayData_\": [1,2,3,4,5,6]\n}\nLikewise, when a JSON object in the above form is serialized using to_bjdata, it is automatically converted into a compact BJData ND-array. The only exception is, that when the 1-dimensional vector stored in \"_ArraySize_\" contains a single integer or two integers with one being 1, a regular 1-D optimized array is generated.
The current version of this library does not yet support automatic detection of and conversion from a nested JSON array input to a BJData ND-array.
Restrictions in optimized data types for arrays and objects
Due to diminished space saving, hampered readability, and increased security risks, in BJData, the allowed data types following the $ marker in an optimized array and object container are restricted to non-zero-fixed-length data types. Therefore, the valid optimized type markers can only be one of UiuImlMLhdDCB. This also means other variable ([{SH) or zero-length types (TFN) can not be used in an optimized array or object in BJData.
Binary values
BJData provides a dedicated B marker (defined in the BJData specification (Draft 3)) that is used in optimized arrays to designate binary data. This means that, unlike UBJSON, binary data can be both serialized and deserialized.
To preserve compatibility with BJData Draft 2, the Draft 3 optimized binary array must be explicitly enabled using the version parameter of to_bjdata.
In Draft2 mode (default), if the JSON data contains the binary type, the value stored as a list of integers, as suggested by the BJData documentation. In particular, this means that the serialization and the deserialization of JSON containing binary values into BJData and back will result in a different JSON object.
Example#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\n// function to print BJData's diagnostic format\nvoid print_byte(uint8_t byte)\n{\n if (32 < byte and byte < 128)\n {\n std::cout << (char)byte;\n }\n else\n {\n std::cout << (int)byte;\n }\n}\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": false})\"_json;\n\n // serialize it to BJData\n std::vector<std::uint8_t> v = json::to_bjdata(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n // create an array of numbers\n json array = {1, 2, 3, 4, 5, 6, 7, 8};\n\n // serialize it to BJData using default representation\n std::vector<std::uint8_t> v_array = json::to_bjdata(array);\n // serialize it to BJData using size optimization\n std::vector<std::uint8_t> v_array_size = json::to_bjdata(array, true);\n // serialize it to BJData using type optimization\n std::vector<std::uint8_t> v_array_size_and_type = json::to_bjdata(array, true, true);\n\n // print the vector contents\n for (auto& byte : v_array)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n for (auto& byte : v_array_size)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n for (auto& byte : v_array_size_and_type)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n}\nOutput:
{i7compactTi6schemaF}\n[i1i2i3i4i5i6i7i8]\n[#i8i1i2i3i4i5i6i7i8\n[$i#i812345678\nThe library maps BJData types to JSON value types as follows:
BJData type JSON value type marker no-op no value, next value is readN null null Z false false F true true T float16 number_float h float32 number_float d float64 number_float D uint8 number_unsigned U int8 number_integer i uint16 number_unsigned u int16 number_integer I uint32 number_unsigned m int32 number_integer l uint64 number_unsigned M int64 number_integer L byte number_unsigned B string string S char string C array array (optimized values are supported) [ ND-array object (in JData annotated array format) [$.#[. object object (optimized values are supported) { binary binary (strongly-typed byte array) [$B Complete mapping
The mapping is complete in the sense that any BJData value can be converted to a JSON value.
Example#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0x7B, 0x69, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x61,\n 0x63, 0x74, 0x54, 0x69, 0x06, 0x73, 0x63, 0x68,\n 0x65, 0x6D, 0x61, 0x69, 0x00, 0x7D\n };\n\n // deserialize it with BJData\n json j = json::from_bjdata(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nBSON, short for Binary JSON, is a binary-encoded serialization of JSON-like documents. Like JSON, BSON supports the embedding of documents and arrays within other documents and arrays. BSON also contains extensions that allow representation of data types that are not part of the JSON spec. For example, BSON has a Date type and a BinData type.
References
The library uses the following mapping from JSON values types to BSON types:
JSON value type value/range BSON type marker nullnull null 0x0A boolean true, false boolean 0x08 number_integer -9223372036854775808..-2147483649 int64 0x12 number_integer -2147483648..2147483647 int32 0x10 number_integer 2147483648..9223372036854775807 int64 0x12 number_unsigned 0..2147483647 int32 0x10 number_unsigned 2147483648..9223372036854775807 int64 0x12 number_unsigned 9223372036854775808..18446744073709551615 uint64 0x11 number_float any value double 0x01 string any value string 0x02 array any value document 0x04 object any value document 0x03 binary any value binary 0x05 Incomplete mapping
The mapping is incomplete, since only JSON-objects (and things contained therein) can be serialized to BSON. Also, keys may not contain U+0000, since they are serialized a zero-terminated c-strings.
Example#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": 0})\"_json;\n\n // serialize it to BSON\n std::vector<std::uint8_t> v = json::to_bson(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n std::cout << \"0x\" << std::hex << std::setw(2) << std::setfill('0') << (int)byte << \" \";\n }\n std::cout << std::endl;\n}\nOutput:
0x1b 0x00 0x00 0x00 0x08 0x63 0x6f 0x6d 0x70 0x61 0x63 0x74 0x00 0x01 0x10 0x73 0x63 0x68 0x65 0x6d 0x61 0x00 0x00 0x00 0x00 0x00 0x00 \nThe library maps BSON record types to JSON value types as follows:
BSON type BSON marker byte JSON value type double 0x01 number_float string 0x02 string document 0x03 object array 0x04 array binary 0x05 binary undefined 0x06 unsupported ObjectId 0x07 unsupported boolean 0x08 boolean UTC Date-Time 0x09 unsupported null 0x0A null Regular Expr. 0x0B unsupported DB Pointer 0x0C unsupported JavaScript Code 0x0D unsupported Symbol 0x0E unsupported JavaScript Code w/ scope 0x0F unsupported int32 0x10 number_integer uint64(Timestamp) 0x11 number_unsigned int64 0x12 number_integer 128-bit decimal float 0x13 unsupported Max Key 0x7F unsupported Min Key 0xFF unsupportedIncomplete mapping
The mapping is incomplete. The unsupported mappings are indicated in the table above.
Handling of BSON type 0x11
BSON type 0x11 is used to represent uint64 numbers. This library treats these values purely as uint64 numbers and does not parse them into date-related formats.
Example#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0x1b, 0x00, 0x00, 0x00, 0x08, 0x63, 0x6f, 0x6d,\n 0x70, 0x61, 0x63, 0x74, 0x00, 0x01, 0x10, 0x73,\n 0x63, 0x68, 0x65, 0x6d, 0x61, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00\n };\n\n // deserialize it with BSON\n json j = json::from_bson(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nThe Concise Binary Object Representation (CBOR) is a data format whose design goals include the possibility of extremely small code sizes, fairly small message size, and extensibility without the need for version negotiation.
References
The library uses the following mapping from JSON values types to CBOR types according to the CBOR specification (RFC 7049):
JSON value type value/range CBOR type first byte nullnull Null 0xF6 boolean true True 0xF5 boolean false False 0xF4 number_integer -9223372036854775808..-2147483649 Negative integer (8 bytes follow) 0x3B number_integer -2147483648..-32769 Negative integer (4 bytes follow) 0x3A number_integer -32768..-129 Negative integer (2 bytes follow) 0x39 number_integer -128..-25 Negative integer (1 byte follow) 0x38 number_integer -24..-1 Negative integer 0x20..0x37 number_integer 0..23 Integer 0x00..0x17 number_integer 24..255 Unsigned integer (1 byte follow) 0x18 number_integer 256..65535 Unsigned integer (2 bytes follow) 0x19 number_integer 65536..4294967295 Unsigned integer (4 bytes follow) 0x1A number_integer 4294967296..18446744073709551615 Unsigned integer (8 bytes follow) 0x1B number_unsigned 0..23 Integer 0x00..0x17 number_unsigned 24..255 Unsigned integer (1 byte follow) 0x18 number_unsigned 256..65535 Unsigned integer (2 bytes follow) 0x19 number_unsigned 65536..4294967295 Unsigned integer (4 bytes follow) 0x1A number_unsigned 4294967296..18446744073709551615 Unsigned integer (8 bytes follow) 0x1B number_float any value representable by a float Single-Precision Float 0xFA number_float any value NOT representable by a float Double-Precision Float 0xFB string length: 0..23 UTF-8 string 0x60..0x77 string length: 24..255 UTF-8 string (1 byte follow) 0x78 string length: 256..65535 UTF-8 string (2 bytes follow) 0x79 string length: 65536..4294967295 UTF-8 string (4 bytes follow) 0x7A string length: 4294967296..18446744073709551615 UTF-8 string (8 bytes follow) 0x7B array size: 0..23 array 0x80..0x97 array size: 24..255 array (1 byte follow) 0x98 array size: 256..65535 array (2 bytes follow) 0x99 array size: 65536..4294967295 array (4 bytes follow) 0x9A array size: 4294967296..18446744073709551615 array (8 bytes follow) 0x9B object size: 0..23 map 0xA0..0xB7 object size: 24..255 map (1 byte follow) 0xB8 object size: 256..65535 map (2 bytes follow) 0xB9 object size: 65536..4294967295 map (4 bytes follow) 0xBA object size: 4294967296..18446744073709551615 map (8 bytes follow) 0xBB binary size: 0..23 byte string 0x40..0x57 binary size: 24..255 byte string (1 byte follow) 0x58 binary size: 256..65535 byte string (2 bytes follow) 0x59 binary size: 65536..4294967295 byte string (4 bytes follow) 0x5A binary size: 4294967296..18446744073709551615 byte string (8 bytes follow) 0x5B Binary values with subtype are mapped to tagged values (0xD8..0xDB) depending on the subtype, followed by a byte string, see \"binary\" cells in the table above.
Complete mapping
The mapping is complete in the sense that any JSON value type can be converted to a CBOR value.
NaN/infinity handling
If NaN or Infinity are stored inside a JSON number, they are serialized properly. This behavior differs from the normal JSON serialization which serializes NaN or Infinity to null.
Unused CBOR types
The following CBOR types are not used in the conversion:
Tagged items
Binary subtypes will be serialized as tagged items. See binary values for an example.
Example#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": 0})\"_json;\n\n // serialize it to CBOR\n std::vector<std::uint8_t> v = json::to_cbor(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n std::cout << \"0x\" << std::hex << std::setw(2) << std::setfill('0') << (int)byte << \" \";\n }\n std::cout << std::endl;\n}\nOutput:
0xa2 0x67 0x63 0x6f 0x6d 0x70 0x61 0x63 0x74 0xf5 0x66 0x73 0x63 0x68 0x65 0x6d 0x61 0x00 \nThe library maps CBOR types to JSON value types as follows:
CBOR type JSON value type first byte Integer number_unsigned 0x00..0x17 Unsigned integer number_unsigned 0x18 Unsigned integer number_unsigned 0x19 Unsigned integer number_unsigned 0x1A Unsigned integer number_unsigned 0x1B Negative integer number_integer 0x20..0x37 Negative integer number_integer 0x38 Negative integer number_integer 0x39 Negative integer number_integer 0x3A Negative integer number_integer 0x3B Byte string binary 0x40..0x57 Byte string binary 0x58 Byte string binary 0x59 Byte string binary 0x5A Byte string binary 0x5B UTF-8 string string 0x60..0x77 UTF-8 string string 0x78 UTF-8 string string 0x79 UTF-8 string string 0x7A UTF-8 string string 0x7B UTF-8 string string 0x7F array array 0x80..0x97 array array 0x98 array array 0x99 array array 0x9A array array 0x9B array array 0x9F map object 0xA0..0xB7 map object 0xB8 map object 0xB9 map object 0xBA map object 0xBB map object 0xBF Falsefalse 0xF4 True true 0xF5 Null null 0xF6 Half-Precision Float number_float 0xF9 Single-Precision Float number_float 0xFA Double-Precision Float number_float 0xFB Incomplete mapping
The mapping is incomplete in the sense that not all CBOR types can be converted to a JSON value. The following CBOR types are not supported and will yield parse errors:
Object keys
CBOR allows map keys of any type, whereas JSON only allows strings as keys in object values. Therefore, CBOR maps with keys other than UTF-8 strings are rejected.
Tagged items
Tagged items will throw a parse error by default. They can be ignored by passing cbor_tag_handler_t::ignore to function from_cbor. They can be stored by passing cbor_tag_handler_t::store to function from_cbor.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0xa2, 0x67, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63,\n 0x74, 0xf5, 0x66, 0x73, 0x63, 0x68, 0x65, 0x6d,\n 0x61, 0x00\n };\n\n // deserialize it with CBOR\n json j = json::from_cbor(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nMessagePack is an efficient binary serialization format. It lets you exchange data among multiple languages like JSON. But it's faster and smaller. Small integers are encoded into a single byte, and typical short strings require only one extra byte in addition to the strings themselves.
References
The library uses the following mapping from JSON values types to MessagePack types according to the MessagePack specification:
JSON value type value/range MessagePack type first byte nullnull nil 0xC0 boolean true true 0xC3 boolean false false 0xC2 number_integer -9223372036854775808..-2147483649 int64 0xD3 number_integer -2147483648..-32769 int32 0xD2 number_integer -32768..-129 int16 0xD1 number_integer -128..-33 int8 0xD0 number_integer -32..-1 negative fixint 0xE0..0xFF number_integer 0..127 positive fixint 0x00..0x7F number_integer 128..255 uint 8 0xCC number_integer 256..65535 uint 16 0xCD number_integer 65536..4294967295 uint 32 0xCE number_integer 4294967296..18446744073709551615 uint 64 0xCF number_unsigned 0..127 positive fixint 0x00..0x7F number_unsigned 128..255 uint 8 0xCC number_unsigned 256..65535 uint 16 0xCD number_unsigned 65536..4294967295 uint 32 0xCE number_unsigned 4294967296..18446744073709551615 uint 64 0xCF number_float any value representable by a float float 32 0xCA number_float any value NOT representable by a float float 64 0xCB string length: 0..31 fixstr 0xA0..0xBF string length: 32..255 str 8 0xD9 string length: 256..65535 str 16 0xDA string length: 65536..4294967295 str 32 0xDB array size: 0..15 fixarray 0x90..0x9F array size: 16..65535 array 16 0xDC array size: 65536..4294967295 array 32 0xDD object size: 0..15 fix map 0x80..0x8F object size: 16..65535 map 16 0xDE object size: 65536..4294967295 map 32 0xDF binary size: 0..255 bin 8 0xC4 binary size: 256..65535 bin 16 0xC5 binary size: 65536..4294967295 bin 32 0xC6 Complete mapping
The mapping is complete in the sense that any JSON value type can be converted to a MessagePack value.
Any MessagePack output created by to_msgpack can be successfully parsed by from_msgpack.
Size constraints
The following values can not be converted to a MessagePack value:
NaN/infinity handling
If NaN or Infinity are stored inside a JSON number, they are serialized properly in contrast to the dump function which serializes NaN or Infinity to null.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": 0})\"_json;\n\n // serialize it to MessagePack\n std::vector<std::uint8_t> v = json::to_msgpack(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n std::cout << \"0x\" << std::hex << std::setw(2) << std::setfill('0') << (int)byte << \" \";\n }\n std::cout << std::endl;\n}\nOutput:
0x82 0xa7 0x63 0x6f 0x6d 0x70 0x61 0x63 0x74 0xc3 0xa6 0x73 0x63 0x68 0x65 0x6d 0x61 0x00 \nThe library maps MessagePack types to JSON value types as follows:
MessagePack type JSON value type first byte positive fixint number_unsigned 0x00..0x7F fixmap object 0x80..0x8F fixarray array 0x90..0x9F fixstr string 0xA0..0xBF nilnull 0xC0 false false 0xC2 true true 0xC3 float 32 number_float 0xCA float 64 number_float 0xCB uint 8 number_unsigned 0xCC uint 16 number_unsigned 0xCD uint 32 number_unsigned 0xCE uint 64 number_unsigned 0xCF int 8 number_integer 0xD0 int 16 number_integer 0xD1 int 32 number_integer 0xD2 int 64 number_integer 0xD3 str 8 string 0xD9 str 16 string 0xDA str 32 string 0xDB array 16 array 0xDC array 32 array 0xDD map 16 object 0xDE map 32 object 0xDF bin 8 binary 0xC4 bin 16 binary 0xC5 bin 32 binary 0xC6 ext 8 binary 0xC7 ext 16 binary 0xC8 ext 32 binary 0xC9 fixext 1 binary 0xD4 fixext 2 binary 0xD5 fixext 4 binary 0xD6 fixext 8 binary 0xD7 fixext 16 binary 0xD8 negative fixint number_integer 0xE0-0xFF Info
Any MessagePack output created by to_msgpack can be successfully parsed by from_msgpack.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0x82, 0xa7, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63,\n 0x74, 0xc3, 0xa6, 0x73, 0x63, 0x68, 0x65, 0x6d,\n 0x61, 0x00\n };\n\n // deserialize it with MessagePack\n json j = json::from_msgpack(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nUniversal Binary JSON (UBJSON) is a binary form directly imitating JSON, but requiring fewer bytes of data. It aims to achieve the generality of JSON, combined with being much easier to process than JSON.
References
The library uses the following mapping from JSON values types to UBJSON types according to the UBJSON specification:
JSON value type value/range UBJSON type marker nullnull null Z boolean true true T boolean false false F number_integer -9223372036854775808..-2147483649 int64 L number_integer -2147483648..-32769 int32 l number_integer -32768..-129 int16 I number_integer -128..127 int8 i number_integer 128..255 uint8 U number_integer 256..32767 int16 I number_integer 32768..2147483647 int32 l number_integer 2147483648..9223372036854775807 int64 L number_unsigned 0..127 int8 i number_unsigned 128..255 uint8 U number_unsigned 256..32767 int16 I number_unsigned 32768..2147483647 int32 l number_unsigned 2147483648..9223372036854775807 int64 L number_unsigned 2147483649..18446744073709551615 high-precision H number_float any value float64 D string with shortest length indicator string S array see notes on optimized format array [ object see notes on optimized format map { Complete mapping
The mapping is complete in the sense that any JSON value type can be converted to a UBJSON value.
Any UBJSON output created by to_ubjson can be successfully parsed by from_ubjson.
Size constraints
The following values can not be converted to a UBJSON value:
Unused UBJSON markers
The following markers are not used in the conversion:
Z: no-op values are not created.C: single-byte strings are serialized with S markers.NaN/infinity handling
If NaN or Infinity are stored inside a JSON number, they are serialized properly. This behavior differs from the dump() function which serializes NaN or Infinity to null.
Optimized formats
The optimized formats for containers are supported: Parameter use_size adds size information to the beginning of a container and removes the closing marker. Parameter use_type further checks whether all elements of a container have the same type and adds the type marker to the beginning of the container. The use_type parameter must only be used together with use_size = true.
Note that use_size = true alone may result in larger representations - the benefit of this parameter is that the receiving side is immediately informed on the number of elements of the container.
Binary values
If the JSON data contains the binary type, the value stored is a list of integers, as suggested by the UBJSON documentation. In particular, this means that serialization and the deserialization of a JSON containing binary values into UBJSON and back will result in a different JSON object.
Example#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\n// function to print UBJSON's diagnostic format\nvoid print_byte(uint8_t byte)\n{\n if (32 < byte and byte < 128)\n {\n std::cout << (char)byte;\n }\n else\n {\n std::cout << (int)byte;\n }\n}\n\nint main()\n{\n // create a JSON value\n json j = R\"({\"compact\": true, \"schema\": false})\"_json;\n\n // serialize it to UBJSON\n std::vector<std::uint8_t> v = json::to_ubjson(j);\n\n // print the vector content\n for (auto& byte : v)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n // create an array of numbers\n json array = {1, 2, 3, 4, 5, 6, 7, 8};\n\n // serialize it to UBJSON using default representation\n std::vector<std::uint8_t> v_array = json::to_ubjson(array);\n // serialize it to UBJSON using size optimization\n std::vector<std::uint8_t> v_array_size = json::to_ubjson(array, true);\n // serialize it to UBJSON using type optimization\n std::vector<std::uint8_t> v_array_size_and_type = json::to_ubjson(array, true, true);\n\n // print the vector contents\n for (auto& byte : v_array)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n for (auto& byte : v_array_size)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n\n for (auto& byte : v_array_size_and_type)\n {\n print_byte(byte);\n }\n std::cout << std::endl;\n}\nOutput:
{i7compactTi6schemaF}\n[i1i2i3i4i5i6i7i8]\n[#i8i1i2i3i4i5i6i7i8\n[$i#i812345678\nThe library maps UBJSON types to JSON value types as follows:
UBJSON type JSON value type marker no-op no value, next value is readN null null Z false false F true true T float32 number_float d float64 number_float D uint8 number_unsigned U int8 number_integer i int16 number_integer I int32 number_integer l int64 number_integer L string string S char string C array array (optimized values are supported) [ object object (optimized values are supported) { Complete mapping
The mapping is complete in the sense that any UBJSON value can be converted to a JSON value.
Example#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // create byte vector\n std::vector<std::uint8_t> v = {0x7B, 0x69, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x61,\n 0x63, 0x74, 0x54, 0x69, 0x06, 0x73, 0x63, 0x68,\n 0x65, 0x6D, 0x61, 0x69, 0x00, 0x7D\n };\n\n // deserialize it with UBJSON\n json j = json::from_ubjson(v);\n\n // print the deserialized JSON value\n std::cout << std::setw(2) << j << std::endl;\n}\nOutput:
{\n \"compact\": true,\n \"schema\": 0\n}\nThere are many ways elements in a JSON value can be accessed:
operator[]atvalueThe at member function performs checked access; that is, it returns a reference to the desired value if it exists and throws a basic_json::out_of_range exception otherwise.
Consider the following JSON value:
{\n \"name\": \"Mary Smith\",\n \"age\": 42,\n \"hobbies\": [\"hiking\", \"reading\"]\n}\nAssume the value is parsed to a json variable j.
j {\"name\": \"Mary Smith\", \"age\": 42, \"hobbies\": [\"hiking\", \"reading\"]} j.at(\"name\") \"Mary Smith\" j.at(\"age\") 42 j.at(\"hobbies\") [\"hiking\", \"reading\"] j.at(\"hobbies\").at(0) \"hiking\" j.at(\"hobbies\").at(1) \"reading\" The return value is a reference, so it can be used to modify the original value.
Write accessj.at(\"name\") = \"John Smith\";\nThis code produces the following JSON value:
{\n \"name\": \"John Smith\",\n \"age\": 42,\n \"hobbies\": [\"hiking\", \"reading\"]\n}\nWhen accessing an invalid index (i.e., an index greater than or equal to the array size) or the passed object key is non-existing, an exception is thrown.
Accessing via invalid index or missing keyj.at(\"hobbies\").at(3) = \"cooking\";\nThis code produces the following exception:
[json.exception.out_of_range.401] array index 3 is out of range\nWhen extended diagnostic messages are enabled by defining JSON_DIAGNOSTICS, the exception further gives information where the key or index is missing or out of range.
[json.exception.out_of_range.401] (/hobbies) array index 3 is out of range\nExceptions
at can only be used with objects (with a string argument) or with arrays (with a numeric argument). For other types, a basic_json::type_error is thrown.basic_json::out_of_range exception exceptions are thrown if the provided key is not found in an object or the provided index is invalid.basic_json::out_of_range exception is thrown basic_json::out_of_range exception is thrown access to invalid array index basic_json::out_of_range exception is thrown basic_json::out_of_range exception is thrown"},{"location":"features/element_access/default_value/","title":"Access with default value: value","text":""},{"location":"features/element_access/default_value/#overview","title":"Overview","text":"In many situations, such as configuration files, missing values are not exceptional, but may be treated as if a default value was present. For this case, use value(key, default_value) which takes the key you want to access and a default value in case there is no value stored with that key.
Consider the following JSON value:
{\n \"logOutput\": \"result.log\",\n \"append\": true\n}\nAssume the value is parsed to a json variable j.
j {\"logOutput\": \"result.log\", \"append\": true} j.value(\"logOutput\", \"logfile.log\") \"result.log\" j.value(\"append\", true) true j.value(\"append\", false) true j.value(\"logLevel\", \"verbose\") \"verbose\""},{"location":"features/element_access/default_value/#notes","title":"Notes","text":"Exceptions
value can only be used with objects. For other types, a basic_json::type_error is thrown.value can be used with both objects and arrays. For other types (null, boolean, number, string), a basic_json::type_error is thrown.Return type
The value function is a template, and the return type of the function is determined by the type of the provided default value unless otherwise specified. This can have unexpected effects. In the example below, we store a 64-bit unsigned integer. We get exactly that value when using operator[]. However, when we call value and provide 0 as default value, then -1 is returned. This occurs, because 0 has type int which overflows when handling the value 18446744073709551615.
To address this issue, either provide a correctly typed default value or use the template parameter to specify the desired return type. Note that this issue occurs even when a value is stored at the provided key, and the default value is not used as the return value.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j = json::parse(R\"({\"uint64\": 18446744073709551615})\");\n\n std::cout << \"operator[]: \" << j[\"uint64\"] << '\\n'\n << \"default value (int): \" << j.value(\"uint64\", 0) << '\\n'\n << \"default value (uint64_t): \" << j.value(\"uint64\", std::uint64_t(0)) << '\\n'\n << \"explicit return value type: \" << j.value<std::uint64_t>(\"uint64\", 0) << '\\n';\n}\nOutput:
operator[]: 18446744073709551615\ndefault value (int): -1\ndefault value (uint64_t): 18446744073709551615\nexplicit return value type: 18446744073709551615\nvalue for access with default valueElements in a JSON object and a JSON array can be accessed via operator[] similar to a std::map and a std::vector, respectively.
Consider the following JSON value:
{\n \"name\": \"Mary Smith\",\n \"age\": 42,\n \"hobbies\": [\"hiking\", \"reading\"]\n}\nAssume the value is parsed to a json variable j.
j {\"name\": \"Mary Smith\", \"age\": 42, \"hobbies\": [\"hiking\", \"reading\"]} j[\"name\"] \"Mary Smith\" j[\"age\"] 42 j[\"hobbies\"] [\"hiking\", \"reading\"] j[\"hobbies\"][0] \"hiking\" j[\"hobbies\"][1] \"reading\" The return value is a reference, so it can modify the original value. In case the passed object key is non-existing, a null value is inserted which can immediately be overwritten.
j[\"name\"] = \"John Smith\";\nj[\"maidenName\"] = \"Jones\";\nThis code produces the following JSON value:
{\n \"name\": \"John Smith\",\n \"maidenName\": \"Jones\",\n \"age\": 42,\n \"hobbies\": [\"hiking\", \"reading\"]\n}\nWhen accessing an invalid index (i.e., an index greater than or equal to the array size), the JSON array is resized such that the passed index is the new maximal index. Intermediate values are filled with null.
null values j[\"hobbies\"][0] = \"running\";\nj[\"hobbies\"][3] = \"cooking\";\nThis code produces the following JSON value:
{\n \"name\": \"John Smith\",\n \"maidenName\": \"Jones\",\n \"age\": 42,\n \"hobbies\": [\"running\", \"reading\", null, \"cooking\"]\n}\nDesign rationale
The library behaves differently to std::vector and std::map:
std::vector::operator[] never inserts a new element.std::map::operator[] is not available for const values.The type json wraps all JSON value types. It would be impossible to remove operator[] for const objects. At the same time, inserting elements for non-const objects is really convenient as it avoids awkward insert calls. To this end, we decided to have an inserting non-const behavior for both arrays and objects.
Info
The access is unchecked. In case the passed object key does not exist or the passed array index is invalid, no exception is thrown.
Danger
NDEBUG or redefine the macro JSON_ASSERT(x). See the documentation on runtime assertions for more information.Exceptions
operator[] can only be used with objects (with a string argument) or with arrays (with a numeric argument). For other types, a basic_json::type_error is thrown.
null value is returned undefined behavior; runtime assertion in debug mode access to invalid array index reference to newly inserted null value is returned; any index between previous maximal index and passed index are filled with null undefined behavior; runtime assertion in debug mode"},{"location":"features/parsing/","title":"Parsing","text":"This library can create a JSON value from a wide range of inputs. This page gives an overview of the available parsing functions and how they behave; the linked pages go into more detail.
"},{"location":"features/parsing/#input","title":"Input","text":"The parse function reads a JSON value from an input. The input can be
std::string, C string, or string literal),std::istream (e.g., an std::ifstream reading from a file),FILE* pointer,std::vector<std::uint8_t>), or// parse from a string\njson j = json::parse(R\"({\"happy\": true, \"pi\": 3.141})\");\n\n// parse from a file\nstd::ifstream f(\"example.json\");\njson data = json::parse(f);\nThe input must be encoded in UTF-8; other encodings are not supported. A single input may contain only one JSON value. Inputs consisting of multiple values separated by newlines are handled by the JSON Lines format.
By default, the library rejects comments and trailing commas. Both can be enabled with parameters of the parse function \u2014 see comments and trailing commas.
The library offers two parsing models:
basic_json value that can be traversed and modified freely. This is what parse does, and it is the right choice for most use cases.sax_parse for the API.You can influence a DOM parse without switching to the SAX interface by passing a parser callback, which is called during parsing and can, for example, discard parts of the input.
"},{"location":"features/parsing/#exceptions","title":"Exceptions","text":"When the input is not valid JSON, the parse function throws an exception by default. If exceptions are undesired or unavailable, the parser can instead return a discarded value, or accept can be used to only check whether an input is valid JSON. See parsing and exceptions for the available options.
parse - deserialize from a compatible inputaccept - check if the input is valid JSONsax_parse - generate SAX eventsThe JSON Lines format is a text format of newline-delimited JSON. In particular:
\\n. As \\r is silently ignored, \\r\\n is also supported.\\n, but is not required to be one.JSON Text example
{\"name\": \"Gilbert\", \"wins\": [[\"straight\", \"7\u2663\"], [\"one pair\", \"10\u2665\"]]}\n{\"name\": \"Alexa\", \"wins\": [[\"two pair\", \"4\u2660\"], [\"two pair\", \"9\u2660\"]]}\n{\"name\": \"May\", \"wins\": []}\n{\"name\": \"Deloise\", \"wins\": [[\"three of a kind\", \"5\u2663\"]]}\nJSON Lines input with more than one value is treated as invalid JSON by the parse or accept functions. To process it line by line, functions like std::getline can be used:
Example: Parse JSON Text input line by line
The example below demonstrates how JSON Lines can be processed.
#include <sstream>\n#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // JSON Lines (see https://jsonlines.org)\n std::stringstream input;\n input << R\"({\"name\": \"Gilbert\", \"wins\": [[\"straight\", \"7\u2663\"], [\"one pair\", \"10\u2665\"]]}\n{\"name\": \"Alexa\", \"wins\": [[\"two pair\", \"4\u2660\"], [\"two pair\", \"9\u2660\"]]}\n{\"name\": \"May\", \"wins\": []}\n{\"name\": \"Deloise\", \"wins\": [[\"three of a kind\", \"5\u2663\"]]}\n)\";\n\n std::string line;\n while (std::getline(input, line))\n {\n std::cout << json::parse(line) << std::endl;\n }\n}\nOutput:
{\"name\":\"Gilbert\",\"wins\":[[\"straight\",\"7\u2663\"],[\"one pair\",\"10\u2665\"]]}\n{\"name\":\"Alexa\",\"wins\":[[\"two pair\",\"4\u2660\"],[\"two pair\",\"9\u2660\"]]}\n{\"name\":\"May\",\"wins\":[]}\n{\"name\":\"Deloise\",\"wins\":[[\"three of a kind\",\"5\u2663\"]]}\nNote
Using operator>> like
json j;\nwhile (input >> j)\n{\n std::cout << j << std::endl;\n}\nwith a JSON Lines input does not work, because the parser will try to parse one value after the last one.
"},{"location":"features/parsing/parse_exceptions/","title":"Parsing and Exceptions","text":"When the input is not valid JSON, an exception of type parse_error is thrown. This exception contains the position in the input where the error occurred, together with a diagnostic message and the last read input token. The exceptions page contains a list of examples for parse error exceptions. In case you process untrusted input, always enclose your code with a try/catch block, like
json j;\ntry\n{\n j = json::parse(my_input);\n}\ncatch (json::parse_error& ex)\n{\n std::cerr << \"parse error at byte \" << ex.byte << std::endl;\n}\nIn case exceptions are undesired or not supported by the environment, there are different ways to proceed:
"},{"location":"features/parsing/parse_exceptions/#switch-off-exceptions","title":"Switch off exceptions","text":"The parse() function accepts a bool parameter allow_exceptions which controls whether an exception is thrown when a parse error occurs (true, default) or whether a discarded value should be returned (false).
json j = json::parse(my_input, nullptr, false);\nif (j.is_discarded())\n{\n std::cerr << \"parse error\" << std::endl;\n}\nNote there is no diagnostic information available in this scenario.
"},{"location":"features/parsing/parse_exceptions/#use-accept-function","title":"Use accept() function","text":"Alternatively, function accept() can be used which does not return a json value, but a bool indicating whether the input is valid JSON.
if (!json::accept(my_input))\n{\n std::cerr << \"parse error\" << std::endl;\n}\nAgain, there is no diagnostic information available.
"},{"location":"features/parsing/parse_exceptions/#user-defined-sax-interface","title":"User-defined SAX interface","text":"Finally, you can implement the SAX interface and decide what should happen in case of a parse error.
This function has the following interface:
bool parse_error(std::size_t position,\n const std::string& last_token,\n const json::exception& ex);\nThe return value indicates whether the parsing should continue, so the function should usually return false.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nclass sax_no_exception : public nlohmann::detail::json_sax_dom_parser<json>\n{\n public:\n sax_no_exception(json& j)\n : nlohmann::detail::json_sax_dom_parser<json>(j, false)\n {}\n\n bool parse_error(std::size_t position,\n const std::string& last_token,\n const json::exception& ex)\n {\n std::cerr << \"parse error at input byte \" << position << \"\\n\"\n << ex.what() << \"\\n\"\n << \"last read: \\\"\" << last_token << \"\\\"\"\n << std::endl;\n return false;\n }\n};\n\nint main()\n{\n std::string myinput = \"[1,2,3,]\";\n\n json result;\n sax_no_exception sax(result);\n\n bool parse_result = json::sax_parse(myinput, &sax);\n if (!parse_result)\n {\n std::cerr << \"parsing unsuccessful!\" << std::endl;\n }\n\n std::cout << \"parsed value: \" << result << std::endl;\n}\nOutput:
parse error at input byte 8\n[json.exception.parse_error.101] parse error at line 1, column 8: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal\nlast read: \"3,]\"\nparsing unsuccessful!\nparsed value: [1,2,3]\nWith a parser callback function, the result of parsing a JSON text can be influenced. When passed to parse, it is called on certain events (passed as parse_event_t via parameter event) with a set recursion depth depth and context JSON value parsed. The return value of the callback function is a boolean indicating whether the element that emitted the callback shall be kept or not.
The type of the callback function is:
template<typename BasicJsonType>\nusing parser_callback_t =\n std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;\nWe distinguish six scenarios (determined by the event type) in which the callback function can be called. The following table describes the values of the parameters depth, event, and parsed.
event description parameter depth parameter parsed parse_event_t::object_start the parser read { and started to process a JSON object depth of the parent of the JSON object a JSON value with type discarded parse_event_t::key the parser read a key of a value in an object depth of the currently parsed JSON object a JSON string containing the key parse_event_t::object_end the parser read } and finished processing a JSON object depth of the parent of the JSON object the parsed JSON object parse_event_t::array_start the parser read [ and started to process a JSON array depth of the parent of the JSON array a JSON value with type discarded parse_event_t::array_end the parser read ] and finished processing a JSON array depth of the parent of the JSON array the parsed JSON array parse_event_t::value the parser finished reading a JSON value depth of the value the parsed JSON value Example When parsing the following JSON text,
{\n \"name\": \"Berlin\",\n \"location\": [\n 52.519444,\n 13.406667\n ]\n}\nthese calls are made to the callback function:
event depth parsedobject_start 0 discarded key 1 \"name\" value 1 \"Berlin\" key 1 \"location\" array_start 1 discarded value 2 52.519444 value 2 13.406667 array_end 1 [52.519444,13.406667] object_end 0 {\"location\":[52.519444,13.406667],\"name\":\"Berlin\"}"},{"location":"features/parsing/parser_callbacks/#return-value","title":"Return value","text":"Discarding a value (i.e., returning false) has different effects depending on the context in which the function was called:
null. This case happens if the top-level element is skipped.The example below demonstrates the parse() function with and without callback function.
#include <iostream>\n#include <iomanip>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n // a JSON text\n auto text = R\"(\n {\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": 100\n },\n \"Animated\" : false,\n \"IDs\": [116, 943, 234, 38793]\n }\n }\n )\";\n\n // parse and serialize JSON\n json j_complete = json::parse(text);\n std::cout << std::setw(4) << j_complete << \"\\n\\n\";\n\n // define parser callback\n json::parser_callback_t cb = [](int depth, json::parse_event_t event, json & parsed)\n {\n // skip object elements with key \"Thumbnail\"\n if (event == json::parse_event_t::key and parsed == json(\"Thumbnail\"))\n {\n return false;\n }\n else\n {\n return true;\n }\n };\n\n // parse (with callback) and serialize JSON\n json j_filtered = json::parse(text, cb);\n std::cout << std::setw(4) << j_filtered << '\\n';\n}\nOutput:
{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Thumbnail\": {\n \"Height\": 125,\n \"Url\": \"http://www.example.com/image/481989943\",\n \"Width\": 100\n },\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\n\n{\n \"Image\": {\n \"Animated\": false,\n \"Height\": 600,\n \"IDs\": [\n 116,\n 943,\n 234,\n 38793\n ],\n \"Title\": \"View from 15th Floor\",\n \"Width\": 800\n }\n}\nThe library uses a SAX-like interface with the following functions:
classDiagram\n\nclass sax_t [\"json::sax_t\"] {\n <<interface>>\n +bool null()*\n\n +bool boolean(bool val)*\n\n +bool number_integer(number_integer_t val)*\n +bool number_unsigned(number_unsigned_t val)*\n\n +bool number_float(number_float_t val, const string_t& s)*\n\n +bool string(string_t& val)*\n +bool binary(binary_t& val)*\n\n +bool start_object(std::size_t elements)*\n +bool end_object()*\n +bool start_array(std::size_t elements)*\n +bool end_array()*\n +bool key(string_t& val)*\n\n +bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex)*\n}// called when null is parsed\nbool null();\n\n// called when a boolean is parsed; value is passed\nbool boolean(bool val);\n\n// called when a signed or unsigned integer number is parsed; value is passed\nbool number_integer(number_integer_t val);\nbool number_unsigned(number_unsigned_t val);\n\n// called when a floating-point number is parsed; value and original string is passed\nbool number_float(number_float_t val, const string_t& s);\n\n// called when a string is parsed; value is passed and can be safely moved away\nbool string(string_t& val);\n// called when a binary value is parsed; value is passed and can be safely moved away\nbool binary(binary_t& val);\n\n// called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)\nbool start_object(std::size_t elements);\nbool end_object();\nbool start_array(std::size_t elements);\nbool end_array();\n// called when an object key is parsed; value is passed and can be safely moved away\nbool key(string_t& val);\n\n// called when a parse error occurs; byte position, the last token, and an exception is passed\nbool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex);\nThe return value of each function determines whether parsing should proceed.
To implement your own SAX handler, proceed as follows:
nlohmann::json_sax<json> as base class, but you can also use any class where the functions described above are implemented and public.my_sax.bool json::sax_parse(input, &my_sax); where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.Note the sax_parse function only returns a bool indicating the result of the last executed SAX event. It does not return json value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your parse_error implementation. Internally, the SAX interface is used for the DOM parser (class json_sax_dom_parser) as well as the acceptor (json_sax_acceptor), see file json_sax.hpp.
This page gives an overview of how JSON values are stored and how this can be configured.
"},{"location":"features/types/#overview","title":"Overview","text":"By default, JSON values are stored as follows:
JSON type C++ type objectstd::map<std::string, basic_json> array std::vector<basic_json> null std::nullptr_t string std::string boolean bool number std::int64_t, std::uint64_t, and double Note there are three different types for numbers - when parsing JSON text, the best fitting type is chosen.
"},{"location":"features/types/#storage","title":"Storage","text":"classDiagram\n\nclass value_t {\n <<enumeration>>\n null\n object\n array\n string\n boolean\n number_integer\n number_unsigned\n number_float\n binary\n discarded\n}\n\nclass json_value {\n <<union>>\n object_t* object\n array_t* array\n string_t* string\n binary_t* binary\n boolean_t boolean\n number_integer_t number_integer\n number_unsigned_t number_unsigned\n number_float_t number_float\n}\n\nclass basic_json {\n -value_t m_type\n -json_value m_value\n +typedef object_t\n +typedef array_t\n +typedef binary_t\n +typedef boolean_t\n +typedef number_integer_t\n +typedef number_unsigned_t\n +typedef number_float_t\n}\n\nbasic_json .. json_value\nbasic_json .. value_tThe data types to store a JSON value are derived from the template arguments passed to class basic_json:
template<\n template<typename U, typename V, typename... Args> class ObjectType = std::map,\n template<typename U, typename... Args> class ArrayType = std::vector,\n class StringType = std::string,\n class BooleanType = bool,\n class NumberIntegerType = std::int64_t,\n class NumberUnsignedType = std::uint64_t,\n class NumberFloatType = double,\n template<typename U> class AllocatorType = std::allocator,\n template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer,\n class BinaryType = std::vector<std::uint8_t>\n>\nclass basic_json;\nType json is an alias for basic_json<> and uses the default types.
From the template arguments, the following types are derived:
using object_comparator_t = std::less<>;\nusing object_t = ObjectType<StringType, basic_json, object_comparator_t,\n AllocatorType<std::pair<const StringType, basic_json>>>;\n\nusing array_t = ArrayType<basic_json, AllocatorType<basic_json>>;\n\nusing string_t = StringType;\n\nusing boolean_t = BooleanType;\n\nusing number_integer_t = NumberIntegerType;\nusing number_unsigned_t = NumberUnsignedType;\nusing number_float_t = NumberFloatType;\n\nusing binary_t = nlohmann::byte_container_with_subtype<BinaryType>;\nRFC 8259 describes JSON objects as follows:
An object is an unordered collection of zero or more name/value pairs, where a name is a string and a value is a string, number, boolean, null, object, or array.
"},{"location":"features/types/#default-type","title":"Default type","text":"With the default values for ObjectType (std::map), StringType (std::string), and AllocatorType (std::allocator), the default value for object_t is:
std::map<\n std::string, // key_type\n basic_json, // value_type\n std::less<>, // key_compare\n std::allocator<std::pair<const std::string, basic_json>> // allocator_type\n>\nThe choice of object_t influences the behavior of the JSON class. With the default type, objects have the following behavior:
{\"key\": 2, \"key\": 1} could be equal to either {\"key\": 1} or {\"key\": 2}.dump) in this order. For instance, both {\"b\": 1, \"a\": 2} and {\"a\": 2, \"b\": 1} will be stored and serialized as {\"a\": 2, \"b\": 1}.{\"b\": 1, \"a\": 2} and {\"a\": 2, \"b\": 1} will be treated as equal.The order in which name/value pairs are added to the object is not preserved by the library. Therefore, iterating an object may return name/value pairs in a different order than they were originally stored. In fact, keys will be traversed in alphabetical order as std::map with std::less is used by default. Please note this behavior conforms to RFC 8259, because any order implements the specified \"unordered\" nature of JSON objects.
RFC 8259 specifies:
An implementation may set limits on the maximum depth of nesting.
In this class, the object's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON object.
Objects are stored as pointers in a basic_json type. That is, for any access to object values, a pointer of type object_t* must be dereferenced.
RFC 8259 describes JSON arrays as follows:
An array is an ordered sequence of zero or more values.
"},{"location":"features/types/#default-type_1","title":"Default type","text":"With the default values for ArrayType (std::vector) and AllocatorType (std::allocator), the default value for array_t is:
std::vector<\n basic_json, // value_type\n std::allocator<basic_json> // allocator_type\n>\nRFC 8259 specifies:
An implementation may set limits on the maximum depth of nesting.
In this class, the array's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON array.
Arrays are stored as pointers in a basic_json type. That is, for any access to array values, a pointer of type array_t* must be dereferenced.
RFC 8259 describes JSON strings as follows:
A string is a sequence of zero or more Unicode characters.
Unicode values are split by the JSON class into byte-sized characters during deserialization.
"},{"location":"features/types/#default-type_2","title":"Default type","text":"With the default values for StringType (std::string), the default value for string_t is std::string.
Strings are stored in UTF-8 encoding. Therefore, functions like std::string::size() or std::string::length() return the number of bytes in the string rather than the number of characters or glyphs.
RFC 8259 states:
Software implementations are typically required to test names of object members for equality. Implementations that transform the textual representation into sequences of Unicode code units and then perform the comparison numerically, code unit by code unit are interoperable in the sense that implementations will agree in all cases on equality or inequality of two strings. For example, implementations that compare strings with escaped characters unconverted may incorrectly find that \"a\\\\b\" and \"a\\u005Cb\" are not equal.
This implementation is interoperable as it does compare strings code unit by code unit.
"},{"location":"features/types/#storage_3","title":"Storage","text":"String values are stored as pointers in a basic_json type. That is, for any access to string values, a pointer of type string_t* must be dereferenced.
RFC 8259 implicitly describes a boolean as a type which differentiates the two literals true and false.
With the default values for BooleanType (bool), the default value for boolean_t is bool.
Boolean values are stored directly inside a basic_json type.
See the number handling article for a detailed discussion on how numbers are handled by this library.
RFC 8259 describes numbers as follows:
The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.
This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer, or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t, and number_float_t are used.
With the default values for NumberIntegerType (std::int64_t), the default value for number_integer_t is std::int64_t. With the default values for NumberUnsignedType (std::uint64_t), the default value for number_unsigned_t is std::uint64_t. With the default values for NumberFloatType (double), the default value for number_float_t is double.
010 will be serialized to 8. During deserialization, leading zeros yield an error.null.RFC 8259 specifies:
An implementation may set limits on the range and precision of numbers.
When the default type is used, the maximal integer number that can be stored is 9223372036854775807 (INT64_MAX) and the minimal integer number that can be stored is -9223372036854775808 (INT64_MIN). Integer numbers that are out of range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored as number_unsigned_t or number_float_t.
When the default type is used, the maximal unsigned integer number that can be stored is 18446744073709551615 (UINT64_MAX) and the minimal integer number that can be stored is 0. Integer numbers that are out of range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored as number_integer_t or number_float_t.
RFC 8259 further states:
Note that when such software is used, numbers that are integers and are in the range [-2^{53}+1, 2^{53}-1] are interoperable in the sense that implementations will agree exactly on their numeric values.
As this range is a subrange of the exactly supported range [INT64_MIN, INT64_MAX], this class's integer type is interoperable.
RFC 8259 states:
This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754-2008 binary64 (double precision) numbers is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.
This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values smaller than -1.79769313486232e+308 and values greater than 1.79769313486232e+308 will be stored as NaN internally and be serialized to null.
Integer number values, unsigned integer number values, and floating-point number values are stored directly inside a basic_json type.
This document describes how the library is handling numbers.
"},{"location":"features/types/number_handling/#background","title":"Background","text":"This section briefly summarizes how the JSON specification describes how numbers should be handled.
"},{"location":"features/types/number_handling/#json-number-syntax","title":"JSON number syntax","text":"JSON defines the syntax of numbers as follows:
RFC 8259, Section 6
The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed.
A fraction part is a decimal point followed by one or more digits.
An exponent part begins with the letter E in uppercase or lowercase, which may be followed by a plus or minus sign. The E and optional sign are followed by one or more digits.
The following railroad diagram from json.org visualizes the number syntax:
"},{"location":"features/types/number_handling/#number-interoperability","title":"Number interoperability","text":"On number interoperability, the following remarks are made:
RFC 8259, Section 6
This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754 binary64 (double precision) numbers [IEEE754] is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision. A JSON number such as 1E400 or 3.141592653589793238462643383279 may indicate potential interoperability problems, since it suggests that the software that created it expects receiving software to have greater capabilities for numeric magnitude and precision than is widely available.
Note that when such software is used, numbers that are integers and are in the range [-2^{53}+1, 2^{53}-1] are interoperable in the sense that implementations will agree exactly on their numeric values.
"},{"location":"features/types/number_handling/#library-implementation","title":"Library implementation","text":"This section describes how this library implements the above number specification.
"},{"location":"features/types/number_handling/#number-storage","title":"Number storage","text":"In the default json type, numbers are stored as std::uint64_t, std::int64_t, and double, respectively. Thereby, std::uint64_t and std::int64_t are used only if they can store the number without loss of precision. If this is impossible (e.g., if the number is too large), the number is stored as double.
Notes
double.std::strtoull, std::strtoll, and std::strtod, respectively.Examples
-12345678912345789123456789 is smaller than INT64_MIN and will be stored as floating-point number -1.2345678912345788e+25.1E3 will be stored as floating-point number 1000.0.double (i.e., numbers that after conversion via std::strtod are not satisfying std::isfinite such as 1E400) will throw exception json.exception.out_of_range.406 during parsing.double. For instance 3.141592653589793238462643383279 is stored as 0x400921fb54442d18. This is the same behavior as the code double x = 3.141592653589793238462643383279;.Interoperability
double. This also concurs with the specification above.The JSON number grammar allows for different ways to express zero, and this library will store zeros differently:
Literal Stored value and type Serialization0 std::uint64_t(0) 0 -0 std::int64_t(0) 0 0.0 double(0.0) 0.0 -0.0 double(-0.0) -0.0 0E0 double(0.0) 0.0 -0E0 double(-0.0) -0.0 That is, -0 is stored as a signed integer, but the serialization does not reproduce the -.
%g printf modifier with std::numeric_limits<double>::max_digits10 significant digits. The rationale is to use the shortest representation while still allowing round-tripping.Notes regarding precision of floating-point numbers
As described above, floating-point numbers are rounded to the nearest double and serialized with the shortest representation to allow round-tripping. This can yield confusing examples:
2555.5599999999999 will be serialized as 2555.56. The reverse can also be true.0.0000972439793401814 will be serialized as 9.72439793401814e-05. The reverse can also be true: 12345E-5 will be serialized as 0.12345.float to double can also introduce rounding errors: float f = 0.3;\njson j = f;\nstd::cout << j << '\\n';\n0.30000001192092896.All examples here can be reproduced by passing the original double value to
std::printf(\"%.*g\\n\", std::numeric_limits<double>::max_digits10, double_value);\nNaN (not-a-number) cannot be expressed with the number syntax described above and are in fact explicitly excluded:
RFC 8259, Section 6
Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.
That is, there is no way to parse a NaN value. However, assignments can store NaN values in a JSON value.
This library serializes NaN values as null. This corresponds to the behavior of JavaScript's JSON.stringify function.
Example
The following example shows how a NaN value is stored in a json value.
int main()\n{\n double val = std::numeric_limits<double>::quiet_NaN();\n std::cout << \"val=\" << val << std::endl;\n json j = val;\n std::cout << \"j=\" << j.dump() << std::endl;\n val = j;\n std::cout << \"val=\" << val << std::endl;\n}\noutput:
val=nan\nj=null\nval=nan\nFloating-point numbers inside JSON values are compared with json::number_float_t::operator== which is double::operator== by default.
Alternative comparison functions
To compare floating-point while respecting an epsilon, an alternative comparison function could be used, for instance
template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>\ninline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept\n{\n return std::abs(a - b) <= epsilon;\n}\nbool my_equal(const_reference lhs, const_reference rhs)\n{\n const auto lhs_type = lhs.type();\n const auto rhs_type = rhs.type();\n if (lhs_type == rhs_type)\n {\n switch(lhs_type)\n {\n // self_defined case\n case value_t::number_float:\n return std::abs(lhs - rhs) <= std::numeric_limits<float>::epsilon();\n\n // other cases remain the same with the original\n ...\n }\n }\n ...\n}\n(see #703 for more information.)
Note
NaN values never compare equal to themselves or to other NaN values. See #514.
"},{"location":"features/types/number_handling/#number-conversion","title":"Number conversion","text":"Just like the C++ language itself, the get family of functions allows conversions between unsigned and signed integers, and between integers and floating-point values. This behavior may be surprising.
Unconditional number conversions
double d = 42.3; // non-integer double value 42.3\njson jd = d; // stores double value 42.3\nstd::int64_t i = jd.get<std::int64_t>(); // now i==42; no warning or error is produced\nNote the last line with throw a json.exception.type_error.302 exception if jd is not a numerical type, for instance a string.
Numeric conversions are performed according to the corresponding C++ conversion rules. The library does not perform range checks when converting between numeric types.
In particular, conversions from floating-point values to integer types, or conversions to integer types with a smaller range than the stored value, may produce implementation-defined or undefined behavior if the source value cannot be represented by the target type.
Applications requiring checked conversions should inspect the stored number type with is_number_float(), is_number_integer(), is_number_unsigned(), or type(), and perform explicit range checks before converting to a narrower type.
The rationale is twofold:
Conditional number conversion
The code above can be solved by explicitly checking the nature of the value with members such as is_number_integer() or is_number_unsigned():
// check if jd is really integer-valued\nif (jd.is_number_integer())\n{\n // if so, do the conversion and use i\n std::int64_t i = jd.get<std::int64_t>();\n // ...\n}\nelse\n{\n // otherwise, take appropriate action\n // ...\n}\nNote this approach also has the advantage that it can react on non-numerical JSON value types such as strings.
(Example taken from #777.)
"},{"location":"features/types/number_handling/#determine-number-types","title":"Determine number types","text":"As the example in Number conversion shows, there are different functions to determine the type of the stored number:
is_number() returns true for any number typeis_number_integer() returns true for signed and unsigned integersis_number_unsigned() returns true for unsigned integers onlyis_number_float() returns true for floating-point numberstype_name() returns \"number\" for any number typetype() returns a different enumerator of value_t for all number typesis_number() true true true false is_number_integer() true true false false is_number_unsigned() true false false false is_number_float() false false true false type_name() \"number\" \"number\" \"number\" \"string\" type() number_unsigned number_integer number_float string"},{"location":"features/types/number_handling/#template-number-types","title":"Template number types","text":"The number types can be changed with template parameters.
position number type default type possible values 5 signed integersstd::int64_t std::int32_t, std::int16_t, etc. 6 unsigned integers std::uint64_t std::uint32_t, std::uint16_t, etc. 7 floating-point double float, long double Constraints on number types
long long. The type for floating-point numbers is used in case of overflow.unsigned long long. The type for floating-point numbers is used in case of overflow.double, float, and long double are supported for floating-point numbers.Example
A basic_json type that uses long double as floating-point type.
using json_ld = nlohmann::basic_json<std::map, std::vector, std::string, bool,\n std::int64_t, std::uint64_t, long double>;\nNote values should then be parsed with json_ld::parse rather than json::parse as the latter would parse floating-point values to double before then converting them to long double.
Info
This page is still under construction. Its goal is to provide a high-level overview of the library's architecture. This should help new contributors to get an idea of the used concepts and where to make changes.
"},{"location":"home/architecture/#overview","title":"Overview","text":"The main structure is class nlohmann::basic_json.
basic_jsonjsonordered_json via ordered_mapValues are stored as a tagged union of value_t and json_value.
/// the type of the current element\nvalue_t m_type = value_t::null;\n\n/// the value of the current element\njson_value m_value = {};\nwith
enum class value_t : std::uint8_t\n{\n null, ///< null value\n object, ///< object (unordered set of name/value pairs)\n array, ///< array (ordered collection of values)\n string, ///< string value\n boolean, ///< boolean value\n number_integer, ///< number value (signed integer)\n number_unsigned, ///< number value (unsigned integer)\n number_float, ///< number value (floating-point)\n binary, ///< binary array (ordered collection of bytes)\n discarded ///< discarded by the parser callback function\n};\n\nunion json_value {\n /// object (stored with pointer to save storage)\n object_t *object;\n /// array (stored with pointer to save storage)\n array_t *array;\n /// string (stored with pointer to save storage)\n string_t *string;\n /// binary (stored with pointer to save storage)\n binary_t *binary;\n /// boolean\n boolean_t boolean;\n /// number (integer)\n number_integer_t number_integer;\n /// number (unsigned integer)\n number_unsigned_t number_unsigned;\n /// number (floating-point)\n number_float_t number_float;\n};\nInput is read via input adapters that abstract a source with a common interface:
/// read a single character\nstd::char_traits<char>::int_type get_character() noexcept;\n\n/// read multiple characters to a destination buffer and\n/// returns the number of characters successfully read\ntemplate<class T>\nstd::size_t get_elements(T* dest, std::size_t count = 1);\nList examples of input adapters.
"},{"location":"home/architecture/#sax-interface","title":"SAX Interface","text":"TODO
"},{"location":"home/architecture/#writing-outputs-serialization","title":"Writing outputs (serialization)","text":"Output is written via output adapters:
template<typename T>\nvoid write_character(CharType c);\n\ntemplate<typename CharType>\nvoid write_characters(const CharType* s, std::size_t length);\nList examples of output adapters.
"},{"location":"home/architecture/#value-conversion","title":"Value conversion","text":"template<class T>\nvoid to_json(basic_json& j, const T& t);\n\ntemplate<class T>\nvoid from_json(const basic_json& j, T& t);\nThe library is used in multiple projects, applications, operating systems, etc. The list below is not exhaustive, but the result of an internet search. If you know further customers of the library, please let me know.
"},{"location":"home/customers/#space-exploration","title":"Space Exploration","text":"#include \"json.hpp\"#include <nlohmann/json.hpp>.There are myriads of JSON libraries out there, and each may even have its reason to exist. Our class had these design goals:
Intuitive syntax. In languages such as Python, JSON feels like a first-class data type. We used all the operator magic of modern C++ to achieve the same feeling in your code.
Trivial integration. Our whole code consists of a single header file json.hpp. That's it. No library, no subproject, no dependencies, no complex build system. The class is written in vanilla C++11. All in all, everything should require no adjustment of your compiler flags or project settings.
Serious testing. Our class is heavily unit-tested and covers 100% of the code, including all exceptional behavior. Furthermore, we checked with Valgrind and the Clang Sanitizers that there are no memory leaks. Google OSS-Fuzz additionally runs fuzz tests against all parsers 24/7, effectively executing billions of tests so far. To maintain high quality, the project is following the Core Infrastructure Initiative (CII) best practices.
Other aspects were not so important to us:
Memory efficiency. Each JSON object has an overhead of one pointer (the maximal size of a union) and one enumeration element (1 byte). The default generalization uses the following C++ data types: std::string for strings, int64_t, uint64_t or double for numbers, std::map for objects, std::vector for arrays, and bool for Booleans. However, you can template the generalized class basic_json to your needs.
Speed. There are certainly faster JSON libraries out there. However, if your goal is to speed up your development by adding JSON support with a single header, then this library is the way to go. If you know how to use a std::vector or std::map, you are already set.
See the contribution guidelines for more information.
"},{"location":"home/exceptions/","title":"Exceptions","text":""},{"location":"home/exceptions/#overview","title":"Overview","text":""},{"location":"home/exceptions/#base-type","title":"Base type","text":"All exceptions inherit from class json::exception (which in turn inherits from std::exception). It is used as the base class for all exceptions thrown by the basic_json class. This class can hence be used as \"wildcard\" to catch exceptions.
classDiagram\n direction LR\n class `std::exception` {\n <<interface>>\n }\n\n class `json::exception` {\n +const int id\n +const char* what() const\n }\n\n class `json::parse_error` {\n +const std::size_t byte\n }\n\n class `json::invalid_iterator`\n class `json::type_error`\n class `json::out_of_range`\n class `json::other_error`\n\n `std::exception` <|-- `json::exception`\n `json::exception` <|-- `json::parse_error`\n `json::exception` <|-- `json::invalid_iterator`\n `json::exception` <|-- `json::type_error`\n `json::exception` <|-- `json::out_of_range`\n `json::exception` <|-- `json::other_error`Exceptions are used widely within the library. They can, however, be switched off with either using the compiler flag -fno-exceptions or by defining the symbol JSON_NOEXCEPTION. In this case, exceptions are replaced by abort() calls. You can further control this behavior by defining JSON_THROW_USER (overriding throw), JSON_TRY_USER (overriding try), and JSON_CATCH_USER (overriding catch).
Note that JSON_THROW_USER should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield undefined behavior.
The code below switches off exceptions and creates a log entry with a detailed error message in case of errors.
#include <iostream>\n\n#define JSON_TRY_USER if(true)\n#define JSON_CATCH_USER(exception) if(false)\n#define JSON_THROW_USER(exception) \\\n {std::clog << \"Error in \" << __FILE__ << \":\" << __LINE__ \\\n << \" (function \" << __FUNCTION__ << \") - \" \\\n << (exception).what() << std::endl; \\\n std::abort();}\n\n#include <nlohmann/json.hpp>\nNote the explanatory what() string of exceptions is not available for MSVC if exceptions are disabled, see #2824.
See documentation of JSON_TRY_USER, JSON_CATCH_USER and JSON_THROW_USER for more information.
Exceptions in the library are thrown in the local context of the JSON value they are detected. This makes detailed diagnostics messages, and hence debugging, difficult.
Example#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j;\n j[\"address\"][\"street\"] = \"Fake Street\";\n j[\"address\"][\"housenumber\"] = \"12\";\n\n try\n {\n int housenumber = j[\"address\"][\"housenumber\"];\n }\n catch (const json::exception& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[json.exception.type_error.302] type must be number, but is string\nThis exception can be hard to debug if storing the value \"12\" and accessing it is further apart.
To create better diagnostics messages, each JSON value needs a pointer to its parent value such that a global context (i.e., a path from the root value to the value that led to the exception) can be created. That global context is provided as JSON Pointer.
As this global context comes at the price of storing one additional pointer per JSON value and runtime overhead to maintain the parent relation, extended diagnostics are disabled by default. They can, however, be enabled by defining the preprocessor symbol JSON_DIAGNOSTICS to 1 before including json.hpp.
#include <iostream>\n\n# define JSON_DIAGNOSTICS 1\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n json j;\n j[\"address\"][\"street\"] = \"Fake Street\";\n j[\"address\"][\"housenumber\"] = \"12\";\n\n try\n {\n int housenumber = j[\"address\"][\"housenumber\"];\n }\n catch (const json::exception& e)\n {\n std::cout << e.what() << '\\n';\n }\n}\nOutput:
[json.exception.type_error.302] (/address/housenumber) type must be number, but is string\nNow the exception message contains a JSON Pointer /address/housenumber that indicates which value has the wrong type.
See documentation of JSON_DIAGNOSTICS for more information.
The library throws this exception when a parse error occurs. Parse errors can occur during the deserialization of JSON text, CBOR, MessagePack, as well as when using JSON Patch.
Exceptions have ids 1xx.
Byte index
Member byte holds the byte index of the last read character in the input file.
For an input with n bytes, 1 is the index of the first character and n+1 is the index of the terminating null byte or the end of file. This also holds true when reading a byte vector (CBOR or MessagePack).
ExampleThe following code shows how a parse_error exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // parsing input with a syntax error\n json::parse(\"[1,2,3,]\");\n }\n catch (const json::parse_error& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << '\\n'\n << \"byte position of error: \" << e.byte << std::endl;\n }\n}\nOutput:
message: [json.exception.parse_error.101] parse error at line 1, column 8: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal\nexception id: 101\nbyte position of error: 8\nThis error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member byte indicates the error position.
Example message
Input ended prematurely:
[json.exception.parse_error.101] parse error at 2: unexpected end of input; expected string literal\nNo input:
[json.exception.parse_error.101] parse error at line 1, column 1: attempting to parse an empty input; check that your input string or stream contains the expected JSON\nControl character was not escaped:
[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\\\; last read: '\"<U+0009>'\"\nString was not closed:
[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid string: missing closing quote; last read: '\"'\nInvalid number format:
[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid number; expected '+', '-', or digit after exponent; last read: '1E'\n\\u was not be followed by four hex digits:
[json.exception.parse_error.101] parse error at line 1, column 6: syntax error while parsing value - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u01\"'\nInvalid UTF-8 surrogate pair:
[json.exception.parse_error.101] parse error at line 1, column 13: syntax error while parsing value - invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF; last read: '\"\\uD7FF\\uDC00'\"\nInvalid UTF-8 byte:
[json.exception.parse_error.101] parse error at line 3, column 24: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"vous \\352t'\nTip
JSON uses the \\uxxxx format to describe Unicode characters. Code points above 0xFFFF are split into two \\uxxxx entries (\"surrogate pairs\"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
Example message
parse error at 14: missing or wrong low surrogate\nNote
This exception is not used any more. Instead json.exception.parse_error.101 with a more detailed description is used.
"},{"location":"home/exceptions/#jsonexceptionparse_error103","title":"json.exception.parse_error.103","text":"Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
Example message
parse error: code points above 0x10FFFF are invalid\nNote
This exception is not used any more. Instead json.exception.parse_error.101 with a more detailed description is used.
"},{"location":"home/exceptions/#jsonexceptionparse_error104","title":"json.exception.parse_error.104","text":"RFC 6902 requires a JSON Patch document to be a JSON document that represents an array of objects.
Example message
[json.exception.parse_error.104] parse error: JSON patch must be an array of objects\nAn operation of a JSON Patch document must contain exactly one \"op\" member, whose value indicates the operation to perform. Its value must be one of \"add\", \"remove\", \"replace\", \"move\", \"copy\", or \"test\"; other values are errors.
Example message
[json.exception.parse_error.105] parse error: operation 'add' must have member 'value'\n[json.exception.parse_error.105] parse error: operation 'copy' must have string member 'from'\n[json.exception.parse_error.105] parse error: operation value 'foo' is invalid\nAn array index in a JSON Pointer (RFC 6901) may be 0 or any number without a leading 0.
Example message
[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'\nA JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a / character.
Example message
[json.exception.parse_error.107] parse error at byte 1: JSON pointer must be empty or begin with '/' - was: 'foo'\nIn a JSON Pointer, only ~0 and ~1 are valid escape sequences.
Example message
[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'\nA JSON Pointer array index must be a number.
Example messages
[json.exception.parse_error.109] parse error: array index 'one' is not a number\n[json.exception.parse_error.109] parse error: array index '+1' is not a number\nWhen parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
Example message
[json.exception.parse_error.110] parse error at byte 5: syntax error while parsing CBOR string: unexpected end of input\n[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing UBJSON value: expected end of input; last byte: 0x5A\nAn unexpected byte was read in a binary format or length information is invalid (BSON).
Example messages
[json.exception.parse_error.112] parse error at byte 1: syntax error while parsing CBOR value: invalid byte: 0x1C\n[json.exception.parse_error.112] parse error at byte 1: syntax error while parsing MessagePack value: invalid byte: 0xC1\n[json.exception.parse_error.112] parse error at byte 4: syntax error while parsing BJData size: expected '#' after type information; last byte: 0x02\n[json.exception.parse_error.112] parse error at byte 4: syntax error while parsing UBJSON size: expected '#' after type information; last byte: 0x02\n[json.exception.parse_error.112] parse error at byte 10: syntax error while parsing BSON string: string length must be at least 1, is -2147483648\n[json.exception.parse_error.112] parse error at byte 15: syntax error while parsing BSON binary: byte array length cannot be negative, is -1\nWhile parsing a map key, a value that is not a string has been read.
Example messages
[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing CBOR string: expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0xFF\n[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing MessagePack string: expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0xFF\n[json.exception.parse_error.113] parse error at byte 2: syntax error while parsing UBJSON char: byte after 'C' must be in range 0x00..0x7F; last byte: 0x82\nThe parsing of the corresponding BSON record type is not implemented (yet).
Example message
[json.exception.parse_error.114] parse error at byte 5: Unsupported BSON record type 0xFF\nA UBJSON high-precision number could not be parsed.
Example message
[json.exception.parse_error.115] parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A\nThis exception is thrown if iterators passed to a library function do not match the expected semantics.
Exceptions have ids 2xx.
ExampleThe following code shows how an invalid_iterator exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // calling iterator::key() on non-object iterator\n json j = \"string\";\n json::iterator it = j.begin();\n auto k = it.key();\n }\n catch (const json::invalid_iterator& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.invalid_iterator.207] cannot use key() for non-object iterators\nexception id: 207\nThe iterators passed to constructor basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (first, last) is invalid.
Example message
[json.exception.invalid_iterator.201] iterators are not compatible\nIn the erase or insert function, the passed iterator pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
Example messages
[json.exception.invalid_iterator.202] iterator does not fit current value\n[json.exception.invalid_iterator.202] iterators first and last must point to objects\nEither iterator passed to function erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
Example message
[json.exception.invalid_iterator.203] iterators do not fit current value\nWhen an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (begin(), end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
Example message
[json.exception.invalid_iterator.204] iterators out of range\nWhen an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
Example message
[json.exception.invalid_iterator.205] iterator out of range\nThe iterators passed to constructor basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
Example message
[json.exception.invalid_iterator.206] cannot construct with iterators from null\nThe key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
Example message
[json.exception.invalid_iterator.207] cannot use key() for non-object iterators\nThe operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
Example message
[json.exception.invalid_iterator.208] cannot use operator[] for object iterators\nThe offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
Example message
[json.exception.invalid_iterator.209] cannot use offsets with object iterators\nThe iterator range passed to the insert function is not compatible, meaning they do not belong to the same container. Therefore, the range (first, last) is invalid.
Example message
[json.exception.invalid_iterator.210] iterators do not fit\nThe iterator range passed to the insert function must not be a subrange of the container to insert to.
Example message
[json.exception.invalid_iterator.211] passed iterators may not belong to container\nWhen two iterators are compared, they must belong to the same container.
Example message
[json.exception.invalid_iterator.212] cannot compare iterators of different containers\nThe order of object iterators cannot be compared, because JSON objects are unordered.
Example message
[json.exception.invalid_iterator.213] cannot compare order of object iterators\nCannot retrieve value from iterator: The iterator either refers to a null value, or it refers to a primitive type (number, boolean, or string), but does not match the iterator returned by begin().
Example message
[json.exception.invalid_iterator.214] cannot get value\nThis exception is thrown in case of a type error; that is, a library function is executed on a JSON value whose type does not match the expected semantics.
Exceptions have ids 3xx.
ExampleThe following code shows how a type_error exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // calling push_back() on a string value\n json j = \"string\";\n j.push_back(\"another string\");\n }\n catch (const json::type_error& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.type_error.308] cannot use push_back() with string\nexception id: 308\nTo create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
Example message
[json.exception.type_error.301] cannot create object from initializer list\nDuring implicit or explicit value conversion, the JSON type must be compatible with the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
Example messages
[json.exception.type_error.302] type must be object, but is null\n[json.exception.type_error.302] type must be string, but is object\nTo retrieve a reference to a value stored in a basic_json object with get_ref, the type of the reference must match the value type. For instance, for a JSON array, the ReferenceType must be array_t &.
Example messages
[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object\n[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number\"\nThe at() member functions can only be executed for certain JSON types.
Example messages
[json.exception.type_error.304] cannot use at() with string\n[json.exception.type_error.304] cannot use at() with number\nThe operator[] member functions can only be executed for certain JSON types.
Example messages
[json.exception.type_error.305] cannot use operator[] with a string argument with array\n[json.exception.type_error.305] cannot use operator[] with a numeric argument with object\nThe value() member functions can only be executed for certain JSON types.
Example message
[json.exception.type_error.306] cannot use value() with number\nThe erase() member functions can only be executed for certain JSON types.
Example message
[json.exception.type_error.307] cannot use erase() with string\nThe push_back() and operator+= member functions can only be executed for certain JSON types.
Example message
[json.exception.type_error.308] cannot use push_back() with string\nThe insert() member functions can only be executed for certain JSON types.
Example messages
[json.exception.type_error.309] cannot use insert() with array\n[json.exception.type_error.309] cannot use insert() with number\nThe swap() member functions can only be executed for certain JSON types.
Example message
[json.exception.type_error.310] cannot use swap() with number\nThe emplace() and emplace_back() member functions can only be executed for certain JSON types.
Example messages
[json.exception.type_error.311] cannot use emplace() with number\n[json.exception.type_error.311] cannot use emplace_back() with number\nThe update() member functions can only be executed for certain JSON types.
Example message
[json.exception.type_error.312] cannot use update() with array\nThe unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well-defined.
Example message
[json.exception.type_error.313] invalid value to unflatten\nThe unflatten function only works for an object whose keys are JSON Pointers.
Example message
Calling unflatten() on an array [1,2,3]:
[json.exception.type_error.314] only objects can be unflattened\nThe unflatten() function only works for an object whose keys are JSON Pointers and whose values are primitive.
Example message
Calling unflatten() on an object {\"/1\", [1,2,3]}:
[json.exception.type_error.315] values in object must be primitive\nThe dump() function only works with UTF-8 encoded strings; that is, if you assign a std::string to a JSON value, make sure it is UTF-8 encoded.
Example message
Calling dump() on a JSON value containing an ISO 8859-1 encoded string:
[json.exception.type_error.316] invalid UTF-8 byte at index 15: 0x6F\nTip
dump() function to avoid this exception:json::error_handler_t::replace will replace invalid bytes sequences with U+FFFD json::error_handler_t::ignore will silently ignore invalid byte sequencesThe dynamic type of the object cannot be represented in the requested serialization format (e.g., a raw true or null JSON object cannot be serialized to BSON)
Example messages
Serializing null to BSON:
[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is null\n[1,2,3] to BSON: [json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is array\nTip
Encapsulate the JSON value in an object. That is, instead of serializing true, serialize {\"value\": true}
This exception is thrown in case a library function is called on an input parameter that exceeds the expected range, for instance, in the case of array indices or nonexisting object keys.
Exceptions have ids 4xx.
ExampleThe following code shows how an out_of_range exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main()\n{\n try\n {\n // calling at() for an invalid index\n json j = {1, 2, 3, 4};\n j.at(4) = 10;\n }\n catch (const json::out_of_range& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.out_of_range.401] array index 4 is out of range\nexception id: 401\nThe provided array index i is larger than size-1.
Example message
array index 3 is out of range\nThe special array index - in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
Example message
array index '-' (3) is out of range\nThe provided key was not found in the JSON object.
Example message
key 'foo' not found\nA reference token in a JSON Pointer could not be resolved.
Example message
unresolved reference token 'foo'\nThe JSON Patch operations 'remove' and 'add' cannot be applied to the root element of the JSON value.
Example message
JSON pointer has no parent\nA parsed number could not be stored as without changing it to NaN or INF.
Example message
number overflow parsing '10E1000'\nThis exception previously indicated that the UBJSON and BSON binary formats did not support integer numbers greater than 9223372036854775807 due to limitations in the implemented mapping. However, these limitations have since been resolved, and this exception no longer occurs.
Exception cannot occur any more
The size (following #) of an UBJSON array or object exceeds the maximal capacity.
Example message
excessive array size: 8658170730974374167\nKey identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string.
Example message
BSON key cannot contain code point U+0000 (at byte 2)\nThis exception is thrown when an undefined value is used with NLOHMANN_JSON_SERIALIZE_ENUM_STRICT, or when an array index in a JSON pointer exceeds the range of size_type (e.g., on 32-bit platforms).
Example message
enum value out of range\narray index 18446744073709551616 exceeds size_type\nA JSON Patch add operation cannot be applied because the target location's parent is neither an object nor an array. Per RFC 6902, an add target must reference a member of an existing object or an element of an existing array; a primitive value (string, number, boolean, etc.) cannot receive a new member or element.
Example message
cannot add value: the JSON Patch 'add' target's parent is of type string, but must be an object or array\nNote
This exception was added in version 3.12.x. Before that, this situation hit an internal assertion (aborting the program in debug builds) or was silently ignored when assertions were disabled.
"},{"location":"home/exceptions/#further-exceptions","title":"Further exceptions","text":"This exception is thrown in case of errors that cannot be classified with the other exception types.
Exceptions have ids 5xx.
ExampleThe following code shows how an other_error exception can be caught.
#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\nusing namespace nlohmann::literals;\n\nint main()\n{\n try\n {\n // executing a failing JSON Patch operation\n json value = R\"({\n \"best_biscuit\": {\n \"name\": \"Oreo\"\n }\n })\"_json;\n json patch = R\"([{\n \"op\": \"test\",\n \"path\": \"/best_biscuit/name\",\n \"value\": \"Choco Leibniz\"\n }])\"_json;\n value.patch(patch);\n }\n catch (const json::other_error& e)\n {\n // output exception information\n std::cout << \"message: \" << e.what() << '\\n'\n << \"exception id: \" << e.id << std::endl;\n }\n}\nOutput:
message: [json.exception.other_error.501] unsuccessful: {\"op\":\"test\",\"path\":\"/best_biscuit/name\",\"value\":\"Choco Leibniz\"}\nexception id: 501\nA JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
Example message
Executing {\"op\":\"test\", \"path\":\"/baz\", \"value\":\"bar\"} on {\"baz\": \"qux\"}:
[json.exception.other_error.501] unsuccessful: {\"op\":\"test\",\"path\":\"/baz\",\"value\":\"bar\"}\nQuestion
Why does
json j{true};\nand
json j(true);\nyield different results ([true] vs. true)?
This is a known issue, and -- even worse -- the behavior differs between GCC and Clang. The \"culprit\" for this is the library's constructor overloads for initializer lists to allow syntax like
json array = {1, 2, 3, 4};\nfor arrays and
json object = {{\"one\", 1}, {\"two\", 2}}; \nfor objects.
Tip
To avoid any confusion and ensure portable code, do not use brace initialization with the types basic_json, json, or ordered_json unless you want to create an object or array as shown in the examples above.
To explicitly create a single-element array, use json::array({value}):
json j = json::array({true}); // [true]\nOpt-in copy semantics (since version 3.12.0)
If you define JSON_BRACE_INIT_COPY_SEMANTICS to 1 before including the library, single-element brace initialization is treated as copy/move instead of creating a single-element array:
#define JSON_BRACE_INIT_COPY_SEMANTICS 1\n#include <nlohmann/json.hpp>\n\njson obj = {{\"key\", \"value\"}};\njson j{obj}; // -> {\"key\":\"value\"} (copy, not array)\nWithout the macro (default behavior), json j{obj} creates [{\"key\":\"value\"}]. This opt-in macro fixes issue #5074 while preserving backwards compatibility for existing code.
Question
Can you add an option to ignore trailing commas?
This library does not support any feature that would jeopardize interoperability.
"},{"location":"home/faq/#parse-errors-reading-non-ascii-characters","title":"Parse errors reading non-ASCII characters","text":"Questions
[json.exception.parse_error.101] parse error at line 1, column 53: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"Test\u00e9$')\"The library supports Unicode input as follows:
std::u16string and std::u32string can be parsed, assuming UTF-16 and UTF-32 encoding, respectively. These encodings are not supported when reading from files or other input containers.\\uDEAD) will yield parse errors.std::string), note that its length/size functions return the number of stored bytes rather than the number of characters or glyphs.dump() may throw an exception unless json::error_handler_t::replace or json::error_handler_t::ignore are used as error handlers.In most cases, the parser is right to complain, because the input is not UTF-8 encoded. This is especially true for Microsoft Windows, where Latin-1 or ISO 8859-1 is often the standard encoding.
"},{"location":"home/faq/#wide-string-handling","title":"Wide string handling","text":"Question
Why are wide strings (e.g., std::wstring) dumped as arrays of numbers?
As described above, the library assumes UTF-8 as encoding. To store a wide string, you need to change the encoding.
Example
#include <codecvt> // codecvt_utf8\n#include <locale> // wstring_convert\n\n// encoding function\nstd::string to_utf8(std::wstring& wide_string)\n{\n static std::wstring_convert<std::codecvt_utf8<wchar_t>> utf8_conv;\n return utf8_conv.to_bytes(wide_string);\n}\n\njson j;\nstd::wstring ws = L\"\u8ecaB1234 \u3053\u3093\u306b\u3061\u306f\";\n\nj[\"original\"] = ws;\nj[\"encoded\"] = to_utf8(ws);\n\nstd::cout << j << std::endl;\nThe result is:
{\n \"encoded\": \"\u8ecaB1234 \u3053\u3093\u306b\u3061\u306f\",\n \"original\": [36554, 66, 49, 50, 51, 52, 32, 12371, 12435, 12395, 12385, 12399]\n}\nQuestion
Is it possible to indicate a parse error without throwing an exception?
Yes, see Parsing and exceptions.
"},{"location":"home/faq/#key-name-in-exceptions","title":"Key name in exceptions","text":"Question
Can I get the key of the object item that caused an exception?
Yes, you can. Please define the symbol JSON_DIAGNOSTICS to get extended diagnostics messages.
Question
The library uses std::numeric_limits<number_float_t>::digits10 (15 for IEEE doubles) digits for serialization. This value is sufficient to guarantee roundtripping. If one uses more than this number of digits of precision, then string -> value -> string is not guaranteed to round-trip.
cppreference.com
The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.
Tip
The website https://float.exposed gives a good insight into the internal storage of floating-point numbers.
See this section on the library's number handling for more information.
"},{"location":"home/faq/#using-json-values-with-stdformat-or-fmt","title":"Using JSON values withstd::format or fmt","text":"Question
std::format(\"{}\", j) on a JSON value?fmt::format(\"{}\", j) or fmt::print(\"{}\", j) (the {fmt} library) on a JSON value?std::format works out of the box since version 3.12.x, as long as the standard library provides <format> (see JSON_HAS_STD_FORMAT); see std::formatter<basic_json> for details, including the \"{:#}\" pretty-print spec, indent widths (\"{:2}\"), and custom indent characters (\"{:.>#}\").
For fmt, the library ships format_as, a small customization point fmt looks for via argument-dependent lookup. It only has an effect on fmt 10.0.0 through 11.0.2 \u2014 from fmt 11.1.0 onwards, fmt no longer picks up a format_as overload that returns a std::string. On such versions (or any version, if you also want the same \"{:#}\"/width/fill-and-align spec support that std::formatter<basic_json> has), define your own fmt::formatter specialization; see format_as for a recipe that mirrors it.
If you get ambiguous-overload errors when passing a JSON value to fmt::format/fmt::print without any fmt::formatter<json> specialization in scope, that's fmt picking up basic_json's implicit operator ValueType() conversion operator (see #964 and #958); disabling it via JSON_USE_IMPLICIT_CONVERSIONS 0 avoids the ambiguity.
Question
Why does the code not compile with Android SDK?
Android defaults to using very old compilers and C++ libraries. To fix this, add the following to your Application.mk. This will switch to the LLVM C++ library, the Clang compiler, and enable C++11 and other features disabled by default.
APP_STL := c++_shared\nNDK_TOOLCHAIN_VERSION := clang3.6\nAPP_CPPFLAGS += -frtti -fexceptions\nThe code compiles successfully with Android NDK, Revision 9 - 11 (and possibly later) and CrystaX's Android NDK version 10.
"},{"location":"home/faq/#missing-stl-function","title":"Missing STL function","text":"Questions
'to_string' is not a member of 'std' (or similarly, for strtod or strtof)?This is not an issue with the code, but rather with the compiler itself. On Android, see above to build with a newer environment. For MinGW, please refer to this site and this discussion for information on how to fix this bug. For Android NDK using APP_STL := gnustl_static, please refer to this discussion.
The class is licensed under the MIT License:
Copyright \u00a9 2013-2026 Niels Lohmann
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \u201cSoftware\u201d), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED \u201cAS IS\u201d, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed under the MIT License (see above). Copyright \u00a9 2008-2009 Bj\u00f6rn Hoehrmann bjoern@hoehrmann.de
The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the MIT License (see above). Copyright \u00a9 2009 Florian Loitsch
The class contains a copy of Hedley from Evan Nemerson which is licensed as CC0-1.0.
"},{"location":"home/releases/","title":"Releases","text":"This page summarizes the notable changes of every release and links to the relevant documentation. The complete release notes \u2014 including all changes, the download files, and their checksums \u2014 are published on the GitHub releases page.
"},{"location":"home/releases/#v3120-2025-04-11","title":"v3.12.0 (2025-04-11)","text":"Fixes bugs found in 3.11.3 and adds several features. All changes are backward-compatible.
JSON_DIAGNOSTIC_POSITIONS, exposed through the new start_pos and end_pos member functions.ordered_json) and adds NLOHMANN_DEFINE_DERIVED_TYPE for derived classes.std::optional support (C++17) and lets patch, diff, and flatten work with arbitrary string types.std::filesystem::path conversions, and lowers the minimum CMake version to allow CMake 4.0.Full release notes.
"},{"location":"home/releases/#v3113-2023-11-28","title":"v3.11.3 (2023-11-28)","text":"Adds features and fixes bugs found in 3.11.2. All changes are backward-compatible.
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE and NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE) and a clearer parse error for empty input.adl_serializer's to_json, initializer-list construction when size_type is not int, and many compiler warnings.Full release notes.
"},{"location":"home/releases/#v3112-2022-08-12","title":"v3.11.2 (2022-08-12)","text":"Fixes bugs found in 3.11.1 and restructures the namespace. All changes are backward-compatible.
value function (broken for strings, size types, and nullptr in 3.11.0) and makes json_fwd.hpp self-contained.json_pointer as a key in associative containers and comparing it with strings.Full release notes.
"},{"location":"home/releases/#v3111-2022-08-01","title":"v3.11.1 (2022-08-01)","text":"Fixes a regression from 3.11.0. All changes are backward-compatible.
operator\"\"_json and operator\"\"_json_pointer, which 3.11.0 had moved into a namespace by default.Full release notes.
"},{"location":"home/releases/#v3110-2022-08-01","title":"v3.11.0 (2022-08-01)","text":"One of the largest releases ever. All changes are backward-compatible.
std::string_view as object keys in at, operator[], value, erase, find, contains, and count.operator<=> and <ranges>-compatible iterators.NLOHMANN_JSON_NAMESPACE) and the option to move the UDLs out of the global namespace (JSON_USE_GLOBAL_UDLS).patch_inplace, default values for the conversion macros, and an option to disable enum serialization (JSON_DISABLE_ENUM_SERIALIZATION).This release introduced a UDL regression that was fixed in 3.11.1. Full release notes.
"},{"location":"home/releases/#v3105-2022-01-03","title":"v3.10.5 (2022-01-03)","text":"Bug-fix release. All changes are backward-compatible.
std::filesystem conversions behind compiler-support checks (JSON_HAS_FILESYSTEM), which can be set to 0 to disable them altogether.Full release notes.
"},{"location":"home/releases/#v3104-2021-10-16","title":"v3.10.4 (2021-10-16)","text":"Fixes regressions introduced in 3.10.0. All changes are backward-compatible.
std::filesystem::path conversion (which could trigger a stack overflow and broke compilation on Windows).std::find and std::remove.Full release notes.
"},{"location":"home/releases/#v3103-2021-10-08","title":"v3.10.3 (2021-10-08)","text":"Fixes more regressions from 3.10.0. All changes are backward-compatible.
update and by inserting into arrays.std::vector, and allows conversion from types that only provide begin()/end().Full release notes.
"},{"location":"home/releases/#v3102-2021-08-26","title":"v3.10.2 (2021-08-26)","text":"Re-release of 3.10.1, whose Git tag pointed at the wrong commit due to a bug in the release script. All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v3101-2021-08-24","title":"v3.10.1 (2021-08-24)","text":"Fixes a regression from 3.10.0. All changes are backward-compatible.
ordered_json, and hardens the GDB pretty-printer.Full release notes.
"},{"location":"home/releases/#v3100-2021-08-17","title":"v3.10.0 (2021-08-17)","text":"Feature release. All changes are backward-compatible.
JSON_DIAGNOSTICS) that prepend a JSON pointer to exception messages to pinpoint the offending value.cbor_tag_handler_t store option to keep CBOR tags as binary subtypes.std::byte.JSON_NO_IO to exclude the I/O headers and the JSON_HAS_CPP_* macros to override the detected C++ standard.Full release notes.
"},{"location":"home/releases/#v391-2020-08-06","title":"v3.9.1 (2020-08-06)","text":"Fixes two regressions from 3.9.0. All changes are backward-compatible.
ordered_json interface (e.g. ordered_json::parse).Full release notes.
"},{"location":"home/releases/#v390-2020-07-27","title":"v3.9.0 (2020-07-27)","text":"Feature release adding four long-requested features. All changes are backward-compatible.
parse via the ignore_comments parameter.ordered_json to preserve the insertion order of object keys.NLOHMANN_DEFINE_TYPE_* convenience macros, plus high-precision-number support for UBJSON and CBOR tag handling.Full release notes.
"},{"location":"home/releases/#v380-2020-06-14","title":"v3.8.0 (2020-06-14)","text":"Feature release. All changes are backward-compatible.
LegacyInputIterator container (3\u201310 % faster parsing).contains for JSON pointers and makes the binary from_cbor/from_msgpack/etc. functions respect allow_exceptions.Full release notes.
"},{"location":"home/releases/#v373-2019-11-17","title":"v3.7.3 (2019-11-17)","text":"Fixes a regression from 3.7.2 that could yield quadratic complexity in destructor calls. All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v372-2019-11-10","title":"v3.7.2 (2019-11-10)","text":"Fixes a stack overflow for deeply nested input by making the destructor iterative; parsing is now bounded only by available memory. All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v371-2019-11-06","title":"v3.7.1 (2019-11-06)","text":"Bug-fix release. All changes are backward-compatible.
std::int64_t minimum value and fixes contains for JSON pointers.items with a custom string type and makes json_pointer::back const.Full release notes.
"},{"location":"home/releases/#v370-2019-07-28","title":"v3.7.0 (2019-07-28)","text":"Convenience features and house-keeping. All changes are backward-compatible.
contains overload that checks a JSON pointer without throwing, a generic to_string, and a return value for emplace_back.Full release notes.
"},{"location":"home/releases/#v361-2019-03-20","title":"v3.6.1 (2019-03-20)","text":"Fixes a regression (GCC 7/8 compilation) and a <Windows.h> build error introduced in 3.6.0. All changes are backward-compatible. Full release notes.
Feature release. All changes are backward-compatible.
operator/, push_back, parent_pointer, \u2026).contains function to test for an object key and greatly improves the performance of integer serialization.Full release notes.
"},{"location":"home/releases/#v350-2018-12-22","title":"v3.5.0 (2018-12-22)","text":"Feature release. All changes are backward-compatible.
items function and reading from FILE* in the parse function.eofbit handling on input streams and a bug in the BSON SAX parser.Full release notes.
"},{"location":"home/releases/#v340-2018-10-30","title":"v3.4.0 (2018-10-30)","text":"Feature release. All changes are backward-compatible.
dump (throw, replace with U+FFFD, or ignore) and the NLOHMANN_JSON_SERIALIZE_ENUM macro for enum conversion.Full release notes.
"},{"location":"home/releases/#v330-2018-10-05","title":"v3.3.0 (2018-10-05)","text":"Feature release. All changes are backward-compatible.
get_to function, and an overhauled and documented CMake integration.Full release notes.
"},{"location":"home/releases/#v320-2018-08-20","title":"v3.2.0 (2018-08-20)","text":"Feature release. All changes are backward-compatible.
std::wstring, std::u16string, std::u32string) and std::string_view (C++17), and round-tripping of std::map/std::unordered_map with non-string keys.Full release notes.
"},{"location":"home/releases/#v312-2018-03-14","title":"v3.1.2 (2018-03-14)","text":"Bug-fix release. All changes are backward-compatible.
Full release notes.
"},{"location":"home/releases/#v311-2018-02-13","title":"v3.1.1 (2018-02-13)","text":"Bug-fix release. All changes are backward-compatible.
Full release notes.
"},{"location":"home/releases/#v310-2018-02-01","title":"v3.1.0 (2018-02-01)","text":"Feature release. All changes are backward-compatible.
merge_patch.Full release notes.
"},{"location":"home/releases/#v301-2017-12-29","title":"v3.0.1 (2017-12-29)","text":"Fixes small issues in the JSON Pointer and JSON Patch implementations (invalid \"copy\" targets and non-integer array indices). All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v300-2017-12-17","title":"v3.0.0 (2017-12-17)","text":"First 3.x release \u2014 a major release with breaking changes (see the migration guide).
json::exception and subtypes, each with an identifier).accept function and an allow_exceptions flag for parse, and an update function to merge objects.Full release notes.
"},{"location":"home/releases/#v211-2017-02-25","title":"v2.1.1 (2017-02-25)","text":"Bug-fix release. All changes are backward-compatible.
Full release notes.
"},{"location":"home/releases/#v210-2017-01-28","title":"v2.1.0 (2017-01-28)","text":"Feature release. All changes are backward-compatible.
to_json/from_json, the meta function, and the option to switch off exceptions (JSON_NOEXCEPTION).Full release notes.
"},{"location":"home/releases/#v2010-2017-01-02","title":"v2.0.10 (2017-01-02)","text":"Fixes several security-relevant bugs in the CBOR and MessagePack parsers found by OSS-Fuzz. All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v209-2016-12-16","title":"v2.0.9 (2016-12-16)","text":"Adds the CBOR and MessagePack binary formats. All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v208-2016-12-02","title":"v2.0.8 (2016-12-02)","text":"Adds the emplace and emplace_back functions and improves parsing and serialization performance. All changes are backward-compatible. Full release notes.
Fixes several parser bugs found through the \"Parsing JSON is a Minefield\" study (short files, encoding detection, surrogate pairs). All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v206-2016-10-15","title":"v2.0.6 (2016-10-15)","text":"Fixes operator[] for JSON pointers so that it creates missing values like the other overloads. All changes are backward-compatible. Full release notes.
Fixes a remaining stream end-of-file detection bug in the parser. All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v204-2016-09-11","title":"v2.0.4 (2016-09-11)","text":"Fixes stream end-of-file detection in the parser. All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v203-2016-08-31","title":"v2.0.3 (2016-08-31)","text":"Generalizes the parser to accept any contiguous sequence of one-byte elements and deprecates the input-stream constructor in favor of the parse function. All changes are backward-compatible. Full release notes.
Overhauls the parser (now rejecting unescaped control characters), tightens the class invariants, and cleans up the code. All changes are backward-compatible. Full release notes.
"},{"location":"home/releases/#v201-2016-06-28","title":"v2.0.1 (2016-06-28)","text":"Fixes a performance regression in the dump function by adjusting the stream locale once per serialization. All changes are backward-compatible. Full release notes.
Feature release with a minor (potentially non-backward-compatible) API change from added noexcept and constexpr specifiers.
at and operator[], plus flatten and unflatten.diff and patch, unsigned 64-bit integer support, and locale-independent serialization.Full release notes.
"},{"location":"home/releases/#v110-2016-01-24","title":"v1.1.0 (2016-01-24)","text":"Bug-fix and feature release. All changes are backward-compatible.
get_ref accessor for stored values, and introduces runtime assertions.Full release notes.
"},{"location":"home/releases/#v100-2015-12-28","title":"v1.0.0 (2015-12-28)","text":"First official release. Full release notes.
"},{"location":"home/releases/#see-also","title":"See also","text":"You can sponsor this library at GitHub Sponsors.
"},{"location":"home/sponsors/#priority-sponsor","title":"Priority Sponsor","text":"Thanks everyone!
"},{"location":"integration/","title":"Header only","text":"json.hpp is the single required file in single_include/nlohmann or released here. You need to add
#include <nlohmann/json.hpp>\n\n// for convenience\nusing json = nlohmann::json;\nto the files you want to process JSON and set the necessary switches to enable C++11 (e.g., -std=c++11 for GCC and Clang).
You can further use file single_include/nlohmann/json_fwd.hpp for forward declarations.
You can use the nlohmann_json::nlohmann_json interface target in CMake. This target populates the appropriate usage requirements for INTERFACE_INCLUDE_DIRECTORIES to point to the appropriate include directories and INTERFACE_COMPILE_FEATURES for the necessary C++11 flags.
To use this library from a CMake project, you can locate it directly with find_package() and use the namespaced imported target from the generated package configuration:
Example
CMakeLists.txtcmake_minimum_required(VERSION 3.5)\nproject(ExampleProject LANGUAGES CXX)\n\nfind_package(nlohmann_json 3.12.0 REQUIRED)\n\nadd_executable(example example.cpp)\ntarget_link_libraries(example PRIVATE nlohmann_json::nlohmann_json)\nThe package configuration file, nlohmann_jsonConfig.cmake, can be used either from an install tree or directly out of the build tree.
To embed the library directly into an existing CMake project, place the entire source tree in a subdirectory and call add_subdirectory() in your CMakeLists.txt file.
Example
CMakeLists.txtcmake_minimum_required(VERSION 3.5)\nproject(ExampleProject LANGUAGES CXX)\n\n# If you only include this third party in PRIVATE source files, you do not need to install it\n# when your main project gets installed.\nset(JSON_Install OFF CACHE INTERNAL \"\")\n\nadd_subdirectory(nlohmann_json)\n\nadd_executable(example example.cpp)\ntarget_link_libraries(example PRIVATE nlohmann_json::nlohmann_json)\nNote
Do not use include(nlohmann_json/CMakeLists.txt), since that carries with it unintended consequences that will break the build. It is generally discouraged (although not necessarily well documented as such) to use include(...) for pulling in other CMake projects anyways.
To allow your project to support either an externally supplied or an embedded JSON library, you can use a pattern akin to the following.
Example
CMakeLists.txtproject(ExampleProject LANGUAGES CXX)\n\noption(EXAMPLE_USE_EXTERNAL_JSON \"Use an external JSON library\" OFF)\n\nadd_subdirectory(thirdparty)\n\nadd_executable(example example.cpp)\n\n# Note that the namespaced target will always be available regardless of the import method\ntarget_link_libraries(example PRIVATE nlohmann_json::nlohmann_json)\nif(EXAMPLE_USE_EXTERNAL_JSON)\n find_package(nlohmann_json 3.12.0 REQUIRED)\nelse()\n set(JSON_BuildTests OFF CACHE INTERNAL \"\")\n add_subdirectory(nlohmann_json)\nendif()\nthirdparty/nlohmann_json is then a complete copy of this source tree.
Since CMake v3.11, FetchContent can be used to automatically download a release as a dependency at configure time.
Example
CMakeLists.txtcmake_minimum_required(VERSION 3.11)\nproject(ExampleProject LANGUAGES CXX)\n\ninclude(FetchContent)\n\nFetchContent_Declare(json URL https://github.com/nlohmann/json/releases/download/v3.12.0/json.tar.xz)\nFetchContent_MakeAvailable(json)\n\nadd_executable(example example.cpp)\ntarget_link_libraries(example PRIVATE nlohmann_json::nlohmann_json)\nNote
It is recommended to use the URL approach described above which is supported as of version 3.10.0. It is also possible to pass the Git repository like
FetchContent_Declare(json\n GIT_REPOSITORY https://github.com/nlohmann/json\n GIT_TAG v3.12.0\n)\nHowever, the repository https://github.com/nlohmann/json download size is quite large.
"},{"location":"integration/cmake/#cmake-options","title":"CMake Options","text":""},{"location":"integration/cmake/#json_buildtests","title":"JSON_BuildTests","text":"Build the unit tests when BUILD_TESTING is enabled. This option is ON by default if the library's CMake project is the top project. That is, when integrating the library as described above, the test suite is not built unless explicitly switched on with this option.
JSON_CI","text":"Enable CI build targets. The exact targets are used during the several CI steps and are subject to change without notice. This option is OFF by default.
JSON_Diagnostics","text":"Enable extended diagnostic messages by defining macro JSON_DIAGNOSTICS. This option is OFF by default.
JSON_Diagnostic_Positions","text":"Enable position diagnostics by defining macro JSON_DIAGNOSTIC_POSITIONS. This option is OFF by default.
JSON_DisableEnumSerialization","text":"Disable default enum serialization by defining the macro JSON_DISABLE_ENUM_SERIALIZATION. This option is OFF by default.
JSON_FastTests","text":"Skip expensive/slow test suites. This option is OFF by default. Depends on JSON_BuildTests.
JSON_GlobalUDLs","text":"Place user-defined string literals in the global namespace by defining the macro JSON_USE_GLOBAL_UDLS. This option is OFF by default.
JSON_ImplicitConversions","text":"Enable implicit conversions by defining macro JSON_USE_IMPLICIT_CONVERSIONS. This option is ON by default.
JSON_Install","text":"Install CMake targets during install step. This option is ON by default if the library's CMake project is the top project.
JSON_LegacyDiscardedValueComparison","text":"Enable the (incorrect) legacy comparison behavior of discarded JSON values by defining macro JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON. This option is OFF by default.
JSON_MultipleHeaders","text":"Use the non-amalgamated version of the library. This option is ON by default.
JSON_SystemInclude","text":"Treat the library headers like system headers (i.e., adding SYSTEM to the target_include_directories call) to check for this library by tools like Clang-Tidy. This option is OFF by default.
JSON_Valgrind","text":"Execute the test suite with Valgrind. This option is OFF by default. Depends on JSON_BuildTests.
NLOHMANN_JSON_BUILD_MODULES","text":"Build the experimental C++ module nlohmann.json (requires CMake 3.28 or later and C++20). This option is OFF by default.
This page collects some guidelines on how to future-proof your code for future versions of this library.
"},{"location":"integration/migration_guide/#replace-deprecated-functions","title":"Replace deprecated functions","text":"The following functions have been deprecated and will be removed in the next major version (i.e., 4.0.0). All deprecations are annotated with HEDLEY_DEPRECATED_FOR to report which function to use instead.
Function friend std::istream& operator<<(basic_json&, std::istream&) is deprecated since 3.0.0. Please use friend std::istream& operator>>(std::istream&, basic_json&) instead.
nlohmann::json j;\nstd::stringstream ss(\"[1,2,3]\");\nj << ss;\nnlohmann::json j;\nstd::stringstream ss(\"[1,2,3]\");\nss >> j;\nPassing iterator pairs or pointer/length pairs to parsing functions (parse, accept, sax_parse, from_cbor, from_msgpack, from_ubjson, and from_bson via initializer lists is deprecated since 3.8.0. Instead, pass two iterators; for instance, call from_cbor(ptr, ptr+len) instead of from_cbor({ptr, len}).
const char* s = \"[1,2,3]\";\nbool ok = nlohmann::json::accept({s, s + std::strlen(s)});\nconst char* s = \"[1,2,3]\";\nbool ok = nlohmann::json::accept(s, s + std::strlen(s));\nComparing JSON Pointers with strings via operator== and operator!= is deprecated since 3.11.2. To compare a json_pointer p with a string s, convert s to a json_pointer first and use json_pointer::operator== or json_pointer::operator!=.
nlohmann::json::json_pointer lhs(\"/foo/bar/1\");\nassert(lhs == \"/foo/bar/1\");\nnlohmann::json::json_pointer lhs(\"/foo/bar/1\");\nassert(lhs == nlohmann::json::json_pointer(\"/foo/bar/1\"));\nThe implicit conversion from JSON Pointers to string (json_pointer::operator string_t) is deprecated since 3.11.0. Use json_pointer::to_string instead.
nlohmann::json::json_pointer ptr(\"/foo/bar/1\");\nstd::string s = ptr;\nnlohmann::json::json_pointer ptr(\"/foo/bar/1\");\nstd::string s = ptr.to_string();\nPassing a basic_json specialization as template parameter RefStringType to json_pointer is deprecated since 3.11.0. The string type can now be directly provided.
using my_json = nlohmann::basic_json<std::map, std::vector, my_string_type>;\nnlohmann::json_pointer<my_json> ptr(\"/foo/bar/1\");\nnlohmann::json_pointer<my_string_type> ptr(\"/foo/bar/1\");\nThereby, nlohmann::my_json::json_pointer is an alias for nlohmann::json_pointer<my_string_type> and is always an alias to the json_pointer with the appropriate string type for all specializations of basic_json.
The function iterator_wrapper is deprecated since 3.1.0. Please use the member function items instead.
for (auto &x : nlohmann::json::iterator_wrapper(j))\n{\n std::cout << x.key() << \":\" << x.value() << std::endl;\n}\nfor (auto &x : j.items())\n{\n std::cout << x.key() << \":\" << x.value() << std::endl;\n}\nFunction friend std::ostream& operator>>(const basic_json&, std::ostream&) is deprecated since 3.0.0. Please use friend operator<<(std::ostream&, const basic_json&) instead.
j >> std::cout;\nstd::cout << j;\nThe legacy comparison behavior for discarded values is deprecated since 3.11.0. It is already disabled by default and can still be enabled by defining JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON to 1.
#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 1\n#include <nlohmann/json.hpp>\n#include <nlohmann/json.hpp>\nImplicit conversions via operator ValueType will be switched off by default in the next major release of the library.
You can prepare existing code by already defining JSON_USE_IMPLICIT_CONVERSIONS to 0 and replace any implicit conversions with calls to get, get_to, get_ref, or get_ptr.
nlohmann::json j = \"Hello, world!\";\nstd::string s = j;\nnlohmann::json j = \"Hello, world!\";\nauto s = j.get<std::string>();\nnlohmann::json j = \"Hello, world!\";\nstd::string s;\nj.get_to(s);\nliterals for UDLs","text":"The user-defined string literals operator\"\"_json and operator\"\"_json_pointer will be removed from the global namespace in the next major release of the library.
nlohmann::json j = \"[1,2,3]\"_json;\nusing namespace nlohmann::literals;\nnlohmann::json j = \"[1,2,3]\"_json;\nTo prepare existing code, define JSON_USE_GLOBAL_UDLS to 0 and bring the string literals into scope where needed.
The nlohmann namespace contains a sub-namespace to avoid problems when different versions or configurations of the library are used in the same project. Always use nlohmann as namespace or, when the exact version and configuration is relevant, use macro NLOHMANN_JSON_NAMESPACE to denote the namespace.
void to_json(nlohmann::json_abi_v3_11_2::json& j, const person& p)\n{\n j[\"age\"] = p.age;\n}\nvoid to_json(nlohmann::json& j, const person& p)\n{\n j[\"age\"] = p.age;\n}\nvoid to_json(NLOHMANN_JSON_NAMESPACE::json& j, const person& p)\n{\n j[\"age\"] = p.age;\n}\ndetails namespace","text":"The details namespace is not part of the public API of the library and can change in any version without an announcement. Do not rely on any function or type in the details namespace.
Homebrew nlohmann-json Meson nlohmann_json Bazel nlohmann_json Conan nlohmann_json Spack nlohmann-json Hunter nlohmann_json vcpkg nlohmann-json cget nlohmann/json Swift Package Manager nlohmann/json NuGet nlohmann.json Conda nlohmann_json MacPorts nlohmann-json CPM.cmake gh:nlohmann/json xmake nlohmann_json
Throughout this page, we will describe how to compile the example file example.cpp below.
#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nWhen executed, this program should create output similar to
{\n \"compiler\": {\n \"c++\": \"201103\",\n \"family\": \"gcc\",\n \"version\": \"12.4.0\"\n },\n \"copyright\": \"(C) 2013-2026 Niels Lohmann\",\n \"name\": \"JSON for Modern C++\",\n \"platform\": \"apple\",\n \"url\": \"https://github.com/nlohmann/json\",\n \"version\": {\n \"major\": 3,\n \"minor\": 12,\n \"patch\": 0,\n \"string\": \"3.12.0\"\n }\n}\nSummary
formula: nlohmann-json
--HEAD parameter)If you are using Homebrew, you can install the library with
brew install nlohmann-json\nThe header can be used directly in your code or via CMake.
Example: Raw compilationCreate the following file:
example.cpp#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nInstall the package:
brew install nlohmann-json\nCompile the code and pass the Homebrew prefix to the include path such that the library can be found:
c++ example.cpp -I$(brew --prefix nlohmann-json)/include -std=c++11 -o example\nCreate the following files:
example.cpp#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\ncmake_minimum_required(VERSION 3.15)\nproject(json_example)\n\nfind_package(nlohmann_json CONFIG REQUIRED)\n\nadd_executable(json_example example.cpp)\ntarget_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)\nInstall the package:
brew install nlohmann-json\nCompile the code and pass the Homebrew prefix to CMake to find installed packages via find_package:
CMAKE_PREFIX_PATH=$(brew --prefix) cmake -S . -B build\ncmake --build build\nSummary
wrap: nlohmann_json
meson.build.If you are using the Meson Build System, add this source tree as a meson subproject. You may also use the include.zip published in this project's Releases to reduce the size of the vendored source tree. Alternatively, you can get a wrap file by downloading it from Meson WrapDB, or use
meson wrap install nlohmann_json\nPlease see the Meson project for any issues regarding the packaging.
The provided meson.build can also be used as an alternative to CMake for installing nlohmann_json system-wide in which case a pkg-config file is installed. To use it, have your build system require the nlohmann_json pkg-config dependency. In Meson, it is preferred to use the dependency() object with a subproject fallback, rather than using the subproject directly.
Create the following files:
meson.buildproject('json_example', 'cpp',\n version: '1.0',\n default_options: ['cpp_std=c++11']\n)\n\ndependency_json = dependency('nlohmann_json', required: true)\n\nexecutable('json_example',\n sources: ['example.cpp'],\n dependencies: [dependency_json],\n install: true\n)\n#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nUse the Meson WrapDB to fetch the nlohmann/json wrap:
mkdir subprojects\nmeson wrap install nlohmann_json\nBuild:
meson setup build\nmeson compile -C build\nSummary
use bazel_dep, git_override, or local_path_override
This repository provides a Bazel MODULE.bazel and a corresponding BUILD.bazel file. Therefore, this repository can be referenced within a MODULE.bazel by rules such as archive_override, git_override, or local_path_override. To use the library, you need to depend on the target @nlohmann_json//:json (i.e., via deps attribute).
Create the following files:
BUILDcc_binary(\n name = \"main\",\n srcs = [\"example.cpp\"],\n deps = [\"@nlohmann_json//:json\"],\n)\nbazel_dep(name = \"nlohmann_json\", version = \"3.11.3.bcr.1\")\n#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nBuild and run:
bazel build //:main\nbazel run //:main\nSummary
recipe: nlohmann_json
If you are using Conan to manage your dependencies, merely add nlohmann_json/x.y.z to your conanfile's requires, where x.y.z is the release version you want to use.
Create the following files:
Conanfile.txt[requires]\nnlohmann_json/3.12.0\n\n[generators]\nCMakeToolchain\nCMakeDeps\ncmake_minimum_required(VERSION 3.15)\nproject(json_example)\n\nfind_package(nlohmann_json REQUIRED)\n\nadd_executable(json_example example.cpp)\ntarget_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)\n#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nCall Conan:
conan install . --output-folder=build --build=missing\nBuild:
cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=\"conan_toolchain.cmake\" -DCMAKE_BUILD_TYPE=Release\ncmake --build build\nSummary
package: nlohmann-json
If you are using Spack to manage your dependencies, you can use the nlohmann-json package via
spack install nlohmann-json\nPlease see the Spack project for any issues regarding the packaging.
ExampleCreate the following files:
CMakeLists.txtcmake_minimum_required(VERSION 3.15)\nproject(json_example)\n\nfind_package(nlohmann_json REQUIRED)\n\nadd_executable(json_example example.cpp)\ntarget_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)\n#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nInstall the library:
spack install nlohmann-json\nLoad the environment for your Spack-installed packages:
spack load nlohmann-json\nBuild the project with CMake:
cmake -S . -B build -DCMAKE_PREFIX_PATH=$(spack location -i nlohmann-json)\ncmake --build build\nSummary
package: nlohmann_json
If you are using Hunter on your project for external dependencies, then you can use the nlohmann_json package via
hunter_add_package(nlohmann_json)\nPlease see the Hunter project for any issues regarding the packaging.
ExampleCreate the following files:
CMakeLists.txtcmake_minimum_required(VERSION 3.15)\n\ninclude(\"cmake/HunterGate.cmake\")\nHunterGate(\n URL \"https://github.com/cpp-pm/hunter/archive/v0.23.297.tar.gz\"\n SHA1 \"3319fe6a3b08090df7df98dee75134d68e2ef5a3\"\n)\n\nproject(json_example)\n\nhunter_add_package(nlohmann_json)\nfind_package(nlohmann_json CONFIG REQUIRED)\n\nadd_executable(json_example example.cpp)\ntarget_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)\n#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nDownload required files
mkdir cmake\nwget https://raw.githubusercontent.com/cpp-pm/gate/master/cmake/HunterGate.cmake -O cmake/HunterGate.cmake\nBuild the project with CMake:
cmake -S . -B build\ncmake --build build\nSummary
package: nlohmann-json
If you are using vcpkg on your project for external dependencies, then you can install the nlohmann-json package with
vcpkg install nlohmann-json\nand follow the then displayed descriptions. Please see the vcpkg project for any issues regarding the packaging.
ExampleCreate the following files:
CMakeLists.txtcmake_minimum_required(VERSION 3.15)\nproject(json_example)\n\nfind_package(nlohmann_json CONFIG REQUIRED)\n\nadd_executable(json_example example.cpp)\ntarget_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)\n#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nInstall package:
vcpkg install nlohmann-json\nBuild:
cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake\ncmake --build build\nSummary
package: nlohmann/json
If you are using cget, you can install the latest master version with
cget install nlohmann/json\nA specific version can be installed with cget install nlohmann/json@v3.12.0. Also, the multiple header version can be installed by adding the -DJSON_MultipleHeaders=ON flag (i.e., cget install nlohmann/json -DJSON_MultipleHeaders=ON).
Create the following files:
CMakeLists.txtcmake_minimum_required(VERSION 3.15)\nproject(json_example)\n\nfind_package(nlohmann_json CONFIG REQUIRED)\n\nadd_executable(json_example example.cpp)\ntarget_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)\n#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nInitialize cget
cget init\nInstall the library
cget install nlohmann/json\nBuild
cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cget/cget/cget.cmake\ncmake --build build\nSummary
package: nlohmann/json
Summary
package: nlohmann.json
If you are using NuGet, you can use the package nlohmann.json with
dotnet add package nlohmann.json\nProbably the easiest way to use NuGet packages is through Visual Studio graphical interface. Right-click on a project (any C++ project would do) in \u201cSolution Explorer\u201d and select \u201cManage NuGet Packages\u2026\u201d
Now you can click on \u201cBrowse\u201d tab and find the package you like to install.
Most of the packages in NuGet gallery are .NET packages and would not be useful in a C++ project. Microsoft recommends adding \u201cnative\u201d and \u201cnativepackage\u201d tags to C++ NuGet packages to distinguish them, but even adding \u201cnative\u201d to search query would still show many .NET-only packages in the list.
Nevertheless, after finding the package you want, click on \u201cInstall\u201d button and accept confirmation dialogs. After the package is successfully added to the projects, you should be able to build and execute the project without the need for making any more changes to build settings.
Note
A few notes:
.lib, .dll and .pdb for debug info) the different binaries for each supported compiler version must be added to the NuGet package. Some library creators cram binary versions for all supported Visual C++ compiler versions in the same package, so a single package will support all compilers. Some others create a different package for each compiler version (and you usually see things like \u201cv140\u201d or \u201cvc141\u201d in package name to clarify which VC++ compiler this package supports).What happens behind the scenes
After you add a NuGet package, three changes occur in the project source directory. Of course, we could make these changes manually instead of using GUI:
A packages.config file will be created (or updated to include the package name if one such file already exists). This file contains a list of the packages required by this project (name and minimum version) and must be added to the project source code repository, so if you move the source code to a new machine, MSBuild/NuGet knows which packages it has to restore (which it does automatically before each build).
<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<packages>\n <package id=\"nlohmann.json\" version=\"3.5.0\" targetFramework=\"native\" />\n</packages>\nA packages folder which contains actual files in the packages (these are header and binary files required for a successful build, plus a few metadata files). In case of this library for example, it contains json.hpp:
Note
This directory should not be added to the project source code repository, as it will be restored before each build by MSBuild/NuGet. If you go ahead and delete this folder, then build the project again, it will magically re-appear!
Project MSBuild makefile (which for Visual C++ projects has a .vcxproj extension) will be updated to include settings from the package.
The important bit for us here is line 170, which tells MSBuild to import settings from packages\\nlohmann.json.3.5.0\\build\\native\\nlohmann.json.targets file. This is a file the package creator created and added to the package (you can see it is one of the two files I created in this repository, the other just contains package attributes like name and version number). What does it contain?
For our header-only repository, the only setting we need is to add our include directory to the list of AdditionalIncludeDirectories:
<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n <ItemDefinitionGroup>\n <ClCompile>\n <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\n </ClCompile>\n </ItemDefinitionGroup>\n</Project>\nFor libraries with binary files, we will need to add .lib files to linker inputs and add settings to copy .dll and other redistributable files to output directory, if needed.
There are other changes to the makefile as well:
Lines 165-167 add the packages.config as one of project files (so it is shown in Solution Explorer tree view). It is added as None (no build action) and removing it wouldn\u2019t affect build.
Lines 172-177 check to ensure the required packages are present. This will display a build error if package directory is empty (for example when NuGet cannot restore packages because Internet connection is down). Again, if you omit this section, the only change in build would be a more cryptic error message if build fails.
Note
Changes to .vcxproj makefile should also be added to project source code repository.
As you can see, the mechanism NuGet uses to modify project settings is through MSBuild makefiles, so using NuGet with other build systems and compilers (like CMake) as a dependency manager is either impossible or more problematic than useful.
Please refer to this extensive description for more information.
"},{"location":"integration/package_managers/#conda","title":"Conda","text":"Summary
package: nlohmann_json
If you are using conda, you can use the package nlohmann_json from conda-forge executing
conda install -c conda-forge nlohmann_json\nCreate the following file:
example.cpp#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nCreate and activate an environment json:
conda create -n json\nconda activate json\nInstall the package:
conda install -c conda-forge nlohmann_json\nBuild the code:
g++ -std=c++11 -I$(conda info --base)/envs/json/include example.cpp -o example\nIf you are using MSYS2, you can use the mingw-w64-nlohmann-json package, type pacman -S mingw-w64-i686-nlohmann-json or pacman -S mingw-w64-x86_64-nlohmann-json for installation. Please file issues here if you experience problems with the packages.
The package is updated automatically.
"},{"location":"integration/package_managers/#macports","title":"MacPorts","text":"Summary
port: nlohmann-json
If you are using MacPorts, execute
sudo port install nlohmann-json\nto install the nlohmann-json package.
Example: Raw compilationCreate the following file:
example.cpp#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nInstall the package:
sudo port install nlohmann-json\nCompile the code and pass the MacPorts prefix to the include path such that the library can be found:
c++ example.cpp -I/opt/local/include -std=c++11 -o example\nCreate the following files:
example.cpp#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\ncmake_minimum_required(VERSION 3.15)\nproject(json_example)\n\nfind_package(nlohmann_json CONFIG REQUIRED)\n\nadd_executable(json_example example.cpp)\ntarget_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)\nInstall the package:
sudo port install nlohmann-json\nCompile the code:
cmake -S . -B build\ncmake --build build\nSummary
package: nlohmann-json library target: nlohmann-json%lib{json} available in package repositories: - cppget.org (recommended) - package's sources (for advanced users)
3.7.3 (see cppget.org)build2 community in this repository.build2 websiteNote: build2 should not be considered as a standalone package-manager. It is a build-system + package manager + project manager, a set of tools that work hand-in-hand. build2-based projects do not rely on existing CMake scripts and the build scripts defining the project's targets are specific to build2.
To use this package in an existing build2 project, the general steps are:
Make the package available to download from a package repository that provides it.
Your project's repositories.manifest specifies where the package manager will try to acquire packages by default. Make sure one of the repositories specified in this file provides nlohmann-json package. The recommended open-source repository is cppget.org.
If the project has been created using bdep new, cppget.org is already specified in repositories.manifest but commented, just uncomment these lines:
:\nrole: prerequisite\nlocation: https://pkg.cppget.org/1/stable\nAdd this package as dependency of your project.
In your project's manifest add the dependency to the package using depends: nlohmann-json. You could also add some version constraints. For example, to depend on the latest version available:
depends: nlohmann-json\nAdd this library as dependency of your target that uses it.
In the buildfile defining the target that will use this library:
- import the target `lib{json}` from the `nlohmann-json` package, for example:\n ```\n import nljson = nlohmann-json%lib{json}\n ```\n\n- then add the library's target as requirement for your target using it, for example:\n ```\n exe{example} : ... $nljson\n ```\nUse the library in your project's code and build it.
At this point, assuming your project is initialized in a build-configuration, any b or bdep update command that will update/build the project will also acquire the missing dependency automatically, then build it and link it with your target.
If you just want to synchronize dependencies for all your configurations to download the ones you just added:
bdep sync -af\nbuild2's bdep new command Create a new executable project \"example\" (see bdep new command details for the various options to create a new project):
bdep new example\nEdit these files by replacing their content:
example/repositories.manifest: Enable acquiring packages from https://cppget.org by uncommenting the related lines:
: 1\nsummary: example project repository\n\n:\nrole: prerequisite\nlocation: https://pkg.cppget.org/1/stable\n#trust: ...\n\n#:\n#role: prerequisite\n#location: https://git.build2.org/hello/libhello.git\nexample/manifest: Add the latest version of the nlohmann-json package as dependency to the project:
name: example\nversion: 0.1.0-a.0.z\nlanguage: c++\nsummary: example C++ executable\nlicense: other: proprietary ; Not free/open source.\ndescription-file: README.md\nurl: https://example.org/example\nemail: your@emailprovider.com\n#build-error-email: your@emailprovider.com\ndepends: * build2 >= 0.16.0\ndepends: * bpkg >= 0.16.0\n#depends: libhello ^1.0.0\n\ndepends: nlohmann-json\nexample/example/buildfile: import the library's target to be used as requirement for building the executable target exe{example}:
libs =\nimport libs = nlohmann-json%lib{json}\n\nexe{example}: {hxx ixx txx cxx}{**} $libs testscript\n\ncxx.poptions =+ \"-I$out_root\" \"-I$src_root\"\nexample/example/example.cxx: bdep new generates a \"hello world\" by default, replace it by this:
#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nexample/example/testscript: (optional) if you want to be able to test that executable's output is correct using b test:
: json basics\n:\n$* >>~/EOO/\n{\n \"compiler\": {\n/ \"c\\+\\+\": \"\\d+\",/\n/ \"family\": \"[\\w\\d]+\",/\n/ \"version\": \\d+/\n },\n/ \"copyright\": \"\\(C\\) 2013-\\d+ Niels Lohmann\",/\n \"name\": \"JSON for Modern C++\",\n/ \"platform\": \"[\\w\\d]+\",/\n \"url\": \"https://github.com/nlohmann/json\",\n \"version\": {\n \"major\": 3,\n/ \"minor\": \\d+,/\n/ \"patch\": \\d+,/\n/ \"string\": \"3\\.\\d+\\.\\d+\"/\n }\n}\nEOO\nInitialize the project in a default C/C++ build configuration directory, then build and test:
cd example/\n\n# create default C/C++ build configuration in ../example-myconfig/, initialize the project in it (downloads it's dependencies in it too)\nbdep init -C @myconfig cc\n\n# build only,\nb\n\n# or build and test the executable's output, will only work if the `testscript` is correct\nb test\nSummary
package: gh:nlohmann/json
If you are using CPM.cmake, add the CPM.cmake script and the following snippet to your CMake project:
CPMAddPackage(\"gh:nlohmann/json@3.12.0\")\nCreate the following files:
example.cpp#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\ncmake_minimum_required(VERSION 3.15)\nproject(json_example)\n\ninclude(${CMAKE_SOURCE_DIR}/cmake/CPM.cmake)\n\nCPMAddPackage(\"gh:nlohmann/json@3.12.0\")\n\nadd_executable(json_example example.cpp)\ntarget_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)\nDownload CPM.cmake
mkdir -p cmake\nwget -O cmake/CPM.cmake https://github.com/cpm-cmake/CPM.cmake/releases/latest/download/get_cpm.cmake\nBuild
cmake -S . -B build\ncmake --build build\nSummary
package: nlohmann_json
Create the following files:
example.cpp#include <nlohmann/json.hpp>\n#include <iostream>\n#include <iomanip>\n\nusing json = nlohmann::json;\n\nint main()\n{\n std::cout << std::setw(4) << json::meta() << std::endl;\n}\nadd_requires(\"nlohmann_json\")\n\nadd_rules(\"mode.debug\", \"mode.release\")\ntarget(\"xm\")\n set_kind(\"binary\")\n add_files(\"example.cpp\")\n add_packages(\"nlohmann_json\")\n set_languages(\"cxx11\")\nBuild
xmake\nRun
xmake run\nThe library is also contained in many other package repositories:
Package version overview "},{"location":"integration/package_managers/#buckaroo","title":"Buckaroo","text":"If you are using Buckaroo, you can install this library's module with buckaroo add github.com/buckaroo-pm/nlohmann-json. There is a demo repo here.
Warning
The module is outdated as the respective repository has not been updated in years.
"},{"location":"integration/package_managers/#cocoapods","title":"CocoaPods","text":"If you are using CocoaPods, you can use the library by adding pod \"nlohmann_json\", '~>3.1.2' to your podfile (see an example). Please file issues here.
Warning
The module is outdated as the respective pod has not been updated in years.
"},{"location":"integration/pkg-config/","title":"Pkg-config","text":"If you are using bare Makefiles, you can use pkg-config to generate the include flags that point to where the library is installed:
pkg-config nlohmann_json --cflags\nUsers of the Meson build system will also be able to use a system-wide library, which will be found by pkg-config:
json = dependency('nlohmann_json', required: true)\n