// (1) static std::vector<std::uint8_t> to_msgpack(const basic_json& j, const error_handler_t error_handler = error_handler_t::keep); // (2) static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o, const error_handler_t error_handler = error_handler_t::keep); static void to_msgpack(const basic_json& j, detail::output_adapter<char> o, const error_handler_t error_handler = error_handler_t::keep);
Serializes 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.
j (in) : JSON value to serialize
o (in) : output adapter to write serialization to
error_handler (in) : how to treat a string or object key in j that is not valid UTF-8; see error_handler_t. The default, keep, writes the ill-formed bytes to the output as is, as every version of to_msgpack did before this parameter was added and as the MessagePack specification allows; strict throws; replace/ignore sanitize it the same way dump would. Unlike the other binary writers, the default stays keep even if JSON_STRICT_BINARY_UTF8 is enabled.
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
out_of_range.407 if j contains an integer outside [-2^63, 2^64-1], which is only possible with a number type wider than 64 bits; example: "integer number 18446744073709551616 cannot be represented by MessagePack as it does not fit [-2^63, 2^64-1]"out_of_range.412 if the length of a string, binary value, array, or object exceeds 4294967295, the maximum MessagePack can store; example: "MessagePack length 4294967296 exceeds maximum of 4294967295"out_of_range.415 if the subtype of a binary value exceeds 255, the maximum of the MessagePack ext type; example: "subtype 70000 is too large for the MessagePack ext type (max 255)"j is not valid UTF-8 and error_handler is strictj or a value nested in it is discarded; example: "cannot serialize discarded value to MessagePack"Linear in the size of the JSON value j.
??? example “Example: serialize a JSON value to MessagePack”
The example shows the serialization of a JSON value to a byte vector in MessagePack format.
```cpp
#include <iostream>
#include <iomanip>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
using namespace nlohmann::literals;
int main()
{
// create a JSON value
json j = R"({"compact": true, "schema": 0})"_json;
// serialize it to MessagePack
std::vector<std::uint8_t> v = json::to_msgpack(j);
// print the vector content
for (auto& byte : v)
{
std::cout << "0x" << std::hex << std::setw(2) << std::setfill('0') << (int)byte << " ";
}
std::cout << std::endl;
}
```
Output:
```json
0x82 0xa7 0x63 0x6f 0x6d 0x70 0x61 0x63 0x74 0xc3 0xa6 0x73 0x63 0x68 0x65 0x6d 0x61 0x00
```
??? example “Example: out_of_range.415 exception”
The example shows how serializing a binary value whose subtype exceeds 255 throws an exception, because the
MessagePack ext type stores the subtype in a single byte.
```cpp
#include <iostream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
int main()
{
// create a JSON value with a binary subtype that exceeds 255
json j = json::binary({1, 2, 3}, 300);
// exception out_of_range.415
try
{
json::to_msgpack(j);
}
catch (const json::out_of_range& e)
{
std::cout << e.what() << '\n';
}
}
```
Output:
```json
[json.exception.out_of_range.415] subtype 300 is too large for the MessagePack ext type (max 255)
```
out_of_range.412 and out_of_range.415 since version 3.13.0.error_handler parameter in version 3.13.0. Its default, keep, writes the bytes of a string or object key that is not valid UTF-8 unchanged, as before.number_integer_t/number_unsigned_t pairs of different width correctly; before, integers could be serialized with the wrong value if number_integer_t was narrower than number_unsigned_t.type_error.321 for a discarded value since version 3.13.0; previously, a discarded value nested in an array or object was silently skipped, producing invalid MessagePack.out_of_range.407 for integers that do not fit 64 bits since version 3.13.0; previously, integers of a number type wider than 64 bits were silently truncated.