| # <small>nlohmann::basic_json::</small>json_serializer | |
| ```cpp | |
| template<typename T, typename SFINAE> | |
| using json_serializer = JSONSerializer<T, SFINAE>; | |
| ``` | |
| ## Template parameters | |
| `T` | |
| : type to convert; will be used in the `to_json`/`from_json` functions | |
| `SFINAE` | |
| : type to add compile type checks via SFINAE; usually `#!cpp void` | |
| ## Notes | |
| ### Default type | |
| The default values for `json_serializer` is [`adl_serializer`](../adl_serializer/index.md). | |
| ### Requirements | |
| A custom serializer must provide `#!cpp static void to_json(basic_json&, T)` for every type it serializes, and either | |
| `#!cpp static void from_json(const basic_json&, T&)` or `#!cpp static T from_json(const basic_json&)` for every type it | |
| deserializes. See [Template Parameter Requirements](../../features/types/template_parameters.md#jsonserializer). | |
| ## Examples | |
| ??? example | |
| The example below shows how a conversion of a non-default-constructible type is implemented via a specialization of | |
| the `adl_serializer`. | |
| ```cpp | |
| #include <iostream> | |
| #include <nlohmann/json.hpp> | |
| using json = nlohmann::json; | |
| namespace ns | |
| { | |
| // a simple struct to model a person (not default constructible) | |
| struct person | |
| { | |
| person(std::string n, std::string a, int aa) | |
| : name(std::move(n)), address(std::move(a)), age(aa) | |
| {} | |
| std::string name; | |
| std::string address; | |
| int age; | |
| }; | |
| } // namespace ns | |
| namespace nlohmann | |
| { | |
| template <> | |
| struct adl_serializer<ns::person> | |
| { | |
| static ns::person from_json(const json& j) | |
| { | |
| return {j.at("name"), j.at("address"), j.at("age")}; | |
| } | |
| // Here's the catch! You must provide a to_json method! Otherwise, you | |
| // will not be able to convert person to json, since you fully | |
| // specialized adl_serializer on that type | |
| static void to_json(json& j, ns::person p) | |
| { | |
| j["name"] = p.name; | |
| j["address"] = p.address; | |
| j["age"] = p.age; | |
| } | |
| }; | |
| } // namespace nlohmann | |
| int main() | |
| { | |
| json j; | |
| j["name"] = "Ned Flanders"; | |
| j["address"] = "744 Evergreen Terrace"; | |
| j["age"] = 60; | |
| auto p = j.get<ns::person>(); | |
| std::cout << p.name << " (" << p.age << ") lives in " << p.address << std::endl; | |
| } | |
| ``` | |
| Output: | |
| ```json | |
| Ned Flanders (60) lives in 744 Evergreen Terrace | |
| ``` | |
| ## See also | |
| - [adl_serializer](../adl_serializer/index.md) the default `json_serializer` | |
| - [get](get.md) explicit type conversion using the `json_serializer`'s `from_json()` method | |
| - [get_to](get_to.md) explicit type conversion into a variable using the `json_serializer`'s `from_json()` method | |
| - [Arbitrary Type Conversions](../../features/arbitrary_types.md) - the article on converting between JSON values and arbitrary types | |
| ## Version history | |
| - Since version 2.0.0. |