mirror of
https://github.com/nlohmann/json.git
synced 2026-10-13 10:14:53 +00:00
Niels Lohmann
6f2048cd5d
* Accept lvalues in ordered_map::emplace's value parameter
ordered_map::emplace(key, value) took the mapped value only by T&&, an
rvalue reference rather than a forwarding reference, so
ordered_json::emplace("a", value) failed to compile whenever value was
an lvalue or a const lvalue, even though the same call compiles for
json (whose object_t is std::map, with a variadic emplace). Turn the
value parameter into a separately-deduced forwarding reference,
constrained with std::is_constructible so the overloads still only
accept something convertible to the mapped type. std::map-compatible
semantics are unchanged: emplace still does nothing if the key already
exists.
Open PR #5609 also touches ordered_map.hpp (moving values on vector
growth); this change only touches the two emplace() overloads and
should not conflict.
Fixes #5673.
Signed-off-by: Niels Lohmann <mail@nlohmann.me>
* Avoid astyle's padding in ordered_map::emplace's template headers
Use detail::conjunction instead of && and drop the redundant V&& in detail::is_constructible, so astyle keeps the usual template formatting. Addresses review comment by @gregmarr.
Signed-off-by: Niels Lohmann <mail@nlohmann.me>
---------
Signed-off-by: Niels Lohmann <mail@nlohmann.me>
75 lines
2.4 KiB
Markdown
75 lines
2.4 KiB
Markdown
# <small>nlohmann::basic_json::</small>emplace
|
|
|
|
```cpp
|
|
template<class... Args>
|
|
std::pair<iterator, bool> emplace(Args&& ... args);
|
|
```
|
|
|
|
Inserts 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`.
|
|
|
|
## Template parameters
|
|
|
|
`Args`
|
|
: compatible types to create a `basic_json` object
|
|
|
|
## Iterator invalidation
|
|
|
|
For [`ordered_json`](../ordered_json.md), 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.
|
|
|
|
## Parameters
|
|
|
|
`args` (in)
|
|
: arguments to forward to a constructor of `basic_json`
|
|
|
|
## Return value
|
|
|
|
a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and
|
|
a `#!cpp bool` denoting whether the insertion took place.
|
|
|
|
## Exception safety
|
|
|
|
Strong guarantee: if an exception is thrown, there are no changes to any JSON value. As an exception, a `#!json null`
|
|
value is converted to an empty object before the element is added and keeps that type if adding the element throws.
|
|
|
|
## Exceptions
|
|
|
|
Throws [`type_error.311`](../../home/exceptions.md#jsonexceptiontype_error311) when called on a type other than JSON
|
|
object or `#!json null`; example: `"cannot use emplace() with number"`
|
|
|
|
## Complexity
|
|
|
|
Logarithmic in the size of the container, O(log(`size()`)).
|
|
|
|
## Examples
|
|
|
|
??? example
|
|
|
|
The example shows how `emplace()` can be used to add elements to a JSON object. Note how the `#!json 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.
|
|
|
|
```cpp
|
|
--8<-- "examples/emplace.cpp"
|
|
```
|
|
|
|
Output:
|
|
|
|
```json
|
|
--8<-- "examples/emplace.output"
|
|
```
|
|
|
|
## See also
|
|
|
|
- [emplace_back](emplace_back.md) add a value to an array
|
|
- [insert](insert.md) add values to an array/object
|
|
- [Modifying values](../../features/modifying_values.md) - the article on modifying values
|
|
|
|
## Version history
|
|
|
|
- Since version 2.0.8.
|
|
- Fixed in version 3.13.0: for [`ordered_json`](../ordered_json.md), the value could previously only be passed as an
|
|
rvalue; it can now also be passed as an lvalue or a `#!cpp const` lvalue, matching the behavior of `json`.
|