Niels Lohmann
9e67bfa115
* json_view: the library's std conversions read views directly The library's from_json() overloads (containers, maps, std::array, C arrays, pairs, tuples, optional, valarray, forward_list, enums, binary, paths, and scalars) accept views: their traits use the view's basic_json type, and the few accesses that differ (get_ptr) go through small helpers. from_json() of a view now finds them; only the probe still looks up by ADL only. get<T>() of a view thus converts these types without materialize(), with the same values and exceptions; from an object, a repeated key keeps the last value, as parse() does. The view keeps its direct paths for vectors of the types it converts directly (faster than from_json()) and for containers of views; its other vector and map paths are replaced by from_json(). For basic_json, std::valarray and std::forward_list are read in one pass (40 % and 3.5 % fewer instructions); all other conversions are unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * json_view: enable_if_not_view_t instead of '!' in the from_json() templates astyle spaces out the template argument list when it contains a negation; the alias spells the condition with negation<> and leaves the lines alone. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * json_view: compact the template parameter lists astyle had spaced out Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2.8 KiB
2.8 KiB
nlohmann::basic_json_view::get_to
template<typename T>
T& get_to(T& v) const;
Converts the value to T and stores it in v, in one of three ways:
- For the types that
get<T>()converts directly -- arithmetic types,#!cpp bool,#!cpp std::nullptr_t,string_view_t,#!cpp std::basic_string,BasicJsonType,basic_json_view, vectors of these, and maps of views --vis assigned:#!cpp v = get<T>(). - For a type whose
from_json()accepts views (seeget<T>()), thatfrom_json()is called with the view and the existingv, without building aBasicJsonTypevalue. - For every other type, the subtree is built into a
BasicJsonTypevalue and#!cpp materialize().get_to(v)is called, i.e.from_json()is invoked with the existingv, exactly asBasicJsonType::get_to()does.
Template parameters
T- the type to convert the value to
Parameters
v(out)- the variable to store the converted value in
Return value
v, allowing calls to chain
Exception safety
- For the directly converted types: strong exception safety. If an exception is thrown,
vis not modified. - For every other type: as for
BasicJsonType::get_to().materialize()throws beforevis touched, but afrom_json()that throws may leavevpartly modified.
Exceptions
- For the directly converted types: whatever
get<T>()throws for the same value andT. - For every other type: whatever
materialize()andBasicJsonType::get_to()throw.
Complexity
- For the directly converted types: whatever
get<T>()has for the sameT. - For every other type: that of
materialize(), plus that ofBasicJsonType::get_to().
Notes
The difference between the two ways matters for a from_json() that sets only the fields present in the JSON: since
it runs on the existing v, the other fields of v keep their values, whereas assigning get<T>() would replace
them with those of a default-constructed T.
Examples
??? example
The example below reads several fields of a service configuration directly into existing variables, then uses
the returned reference to fold the `#!cpp host`/`#!cpp port` pair into a single string in the same expression.
```cpp
--8<-- "examples/basic_json_view__get_to.cpp"
```
Output:
```json
--8<-- "examples/basic_json_view__get_to.output"
```
See also
- get - convert the value to a given type
BasicJsonType::get_to- the corresponding function ofbasic_json
Version history
- Added in version 3.13.0.