Compare commits

..
Author SHA1 Message Date
Niels Lohmann 5eed8c5433 Document how user-defined views are treated when converting an rvalue
Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-11-17 17:04:18 +01:00
Niels Lohmann 4503e5d9bc Copy instead of move when converting an rvalue non-owning range
Converting an rvalue array-like or object-like container to JSON moves its
elements since the rvalue to_json overloads were added. The check only looked
at the value category, so non-owning ranges (gsl::span, absl::Span, span
backports, iterator ranges), which are usually passed by value, had the
elements of the storage they refer to moved out:

    std::vector<std::string> v = {...};
    json j = make_span(v); // v's strings were left empty

Move only from containers that own their elements, detected by deep
constness: the elements of a const std::vector or std::map are const, while a
const span still gives mutable elements. The rvalue overloads still take
every rvalue container and copy the elements of the others, as in 3.12.0;
this also keeps ranges that can only be iterated when not const working.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-11-16 07:16:10 +01:00
11 changed files with 212 additions and 64 deletions

No files matched your search

@@ -79,7 +79,12 @@ basic_json(basic_json&& other) noexcept;
(e.g., `json j = std::move(vec);` or `json j(std::vector<std::string>{...});`), the elements are moved into (e.g., `json j = std::move(vec);` or `json j(std::vector<std::string>{...});`), the elements are moved into
the JSON value instead of copied. Afterwards, the elements of the source container are in a valid but the JSON value instead of copied. Afterwards, the elements of the source container are in a valid but
unspecified state (**moved-from**). Keys of associative containers are `const` and therefore still copied. unspecified state (**moved-from**). Keys of associative containers are `const` and therefore still copied.
Lvalues and `const` rvalues are copied, and the source is left unchanged. Lvalues and `const` rvalues are copied, and the source is left unchanged. Only containers that own their
elements are moved from, that is, containers whose elements are `const` when accessed through a `const`
container. Non-owning ranges such as spans or iterator ranges (e.g., `gsl::span`, `std::span`) are copied, so
converting an rvalue span leaves the referenced elements unchanged.
A user-defined view whose elements are `const` through a `const` view, but which does not own them, is
treated as owning; pass such a view as an lvalue to copy the elements.
- **numbers**: [`number_integer_t`](number_integer_t.md), [`number_unsigned_t`](number_unsigned_t.md), - **numbers**: [`number_integer_t`](number_integer_t.md), [`number_unsigned_t`](number_unsigned_t.md),
[`number_float_t`](number_float_t.md), and all convertible number types such as `int`, `size_t`, `int64_t`, `float` [`number_float_t`](number_float_t.md), and all convertible number types such as `int`, `size_t`, `int64_t`, `float`
or `double` can be used. or `double` can be used.
+3 -1
View File
@@ -7,7 +7,9 @@ These changes are part of the `develop` branch, but not of a release yet.
2.3 ms). Two consequences: the source container is left in a valid but unspecified (moved-from) state, and if an 2.3 ms). Two consequences: the source container is left in a valid but unspecified (moved-from) state, and if an
exception is thrown during the conversion, the source may be partially moved-from, so the strong exception guarantee exception is thrown during the conversion, the source may be partially moved-from, so the strong exception guarantee
no longer holds for the source of an rvalue conversion (the JSON value itself is unaffected). Lvalues and `const` no longer holds for the source of an rvalue conversion (the JSON value itself is unaffected). Lvalues and `const`
objects are still copied. See [`basic_json`](../../api/basic_json/basic_json.md). objects are still copied, and so are non-owning ranges such as spans (a range whose elements stay mutable through a
`const` range): converting an rvalue span leaves the referenced elements unchanged.
See [`basic_json`](../../api/basic_json/basic_json.md).
- In C++20 (library support for `char8_t`, `__cpp_lib_char8_t`), a `#!cpp std::u8string` is a JSON **string**: - In C++20 (library support for `char8_t`, `__cpp_lib_char8_t`), a `#!cpp std::u8string` is a JSON **string**:
`json j = std::u8string(u8"abc");` stores `"abc"`, and `#!cpp j.get<std::u8string>()` reads it back. Version 3.12.0 `json j = std::u8string(u8"abc");` stores `"abc"`, and `#!cpp j.get<std::u8string>()` reads it back. Version 3.12.0
stored a `#!cpp std::u8string` as an array of code units (`[97,98,99]`); on the 3.13.0 development branch it was stored a `#!cpp std::u8string` as an array of code units (`[97,98,99]`); on the 3.13.0 development branch it was
@@ -48,11 +48,10 @@ namespace detail
{ {
/*! /*!
@brief implements binary to decimal floating-point conversion: the shortest @brief implements the Grisu2 algorithm for binary to decimal floating-point
digits of Zmij (see zmij.hpp) for IEEE 754 binary64 numbers, and the Grisu2 conversion.
algorithm for all other formats.
The Grisu2 implementation is a slightly modified version of the reference This implementation is a slightly modified version of the reference
implementation which may be obtained from implementation which may be obtained from
http://florian.loitsch.com/publications (bench.tar.gz). http://florian.loitsch.com/publications (bench.tar.gz).
+39 -21
View File
@@ -48,30 +48,47 @@ namespace detail
* leave j with the type of the new value, but the pointer to the destroyed old one. * leave j with the type of the new value, but the pointer to the destroyed old one.
*/ */
// a move iterator over the elements of an rvalue container, unless they are // reference type of the elements of a const T
// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a template<typename T>
// std::move_iterator as value_type&&, which cannot bind to a const element using const_range_reference_t = decltype(*std::declval<iterator_t<const T>&>());
template<typename Iterator>
std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/)
{
return std::make_move_iterator(it);
}
template<typename Iterator> // a container that owns its elements propagates constness to them (deep
Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/) // constness): the elements of a const std::vector<std::string> are const. A
{ // non-owning range (a span, an iterator range) has shallow constness: a const
return it; // span still gives mutable access to the elements it refers to. Moving from an
} // rvalue of such a range would empty the storage it refers to, so the elements
// of an rvalue range are only moved if it has deep constness.
template<typename T>
using owns_its_elements = std::is_const<typename std::remove_reference<detected_t<const_range_reference_t, T>>::type>;
template<typename Iterator> template<typename Iterator>
using is_mutable_iterator = std::integral_constant < bool, using is_mutable_iterator = std::integral_constant < bool,
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >; !std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
// a move iterator over the elements of an rvalue container that owns them,
// unless they are const (e.g., std::set): libstdc++ before GCC 5 defines the
// reference of a std::move_iterator as value_type&&, which cannot bind to a
// const element
template<typename Iterator> template<typename Iterator>
auto make_move_iterator_if_mutable(const Iterator& it) std::move_iterator<Iterator> make_move_iterator_if_impl(const Iterator& it, std::true_type /*move*/)
-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
{ {
return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}); return std::make_move_iterator(it);
}
template<typename Iterator>
Iterator make_move_iterator_if_impl(const Iterator& it, std::false_type /*move*/)
{
return it;
}
template<typename Container, typename Iterator>
using moves_elements = conjunction<owns_its_elements<Container>, is_mutable_iterator<Iterator>>;
template<typename Container, typename Iterator>
auto make_move_iterator_if_owned(const Iterator& it)
-> decltype(make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {}))
{
return make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {});
} }
template<value_t> struct external_constructor; template<value_t> struct external_constructor;
@@ -193,14 +210,14 @@ struct external_constructor<value_t::array>
j.replace_value(value_t::array, value); j.replace_value(value_t::array, value);
} }
/// an rvalue container: move its elements /// an rvalue container: move its elements if it owns them
template<typename BasicJsonType, typename CompatibleArrayType> template<typename BasicJsonType, typename CompatibleArrayType>
static void construct_moving(BasicJsonType& j, CompatibleArrayType& arr) static void construct_moving(BasicJsonType& j, CompatibleArrayType& arr)
{ {
using std::begin; using std::begin;
using std::end; using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr)))); const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_owned<CompatibleArrayType>(begin(arr)), make_move_iterator_if_owned<CompatibleArrayType>(end(arr))));
j.replace_value(value_t::array, value); j.replace_value(value_t::array, value);
} }
@@ -254,14 +271,14 @@ struct external_constructor<value_t::object>
j.replace_value(value_t::object, value); j.replace_value(value_t::object, value);
} }
/// an rvalue container: move its values /// an rvalue container: move its values if it owns them
template<typename BasicJsonType, typename CompatibleObjectType> template<typename BasicJsonType, typename CompatibleObjectType>
static void construct_moving(BasicJsonType& j, CompatibleObjectType& obj) static void construct_moving(BasicJsonType& j, CompatibleObjectType& obj)
{ {
using std::begin; using std::begin;
using std::end; using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj)))); const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_owned<CompatibleObjectType>(begin(obj)), make_move_iterator_if_owned<CompatibleObjectType>(end(obj))));
j.replace_value(value_t::object, value); j.replace_value(value_t::object, value);
} }
@@ -456,7 +473,8 @@ using is_rvalue_array_to_json = conjunction<is_movable_container_rvalue<T>,
is_compatible_string_type<BasicJsonType, T>, is_compatible_string_type<BasicJsonType, T>,
is_compatible_binary_type<BasicJsonType, T>>>>; is_compatible_binary_type<BasicJsonType, T>>>>;
// rvalue containers: their elements are moved instead of copied // rvalue containers: their elements are moved instead of copied if the
// container owns them (see owns_its_elements)
template<typename BasicJsonType, typename CompatibleArrayType, template<typename BasicJsonType, typename CompatibleArrayType,
enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0> enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0>
inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward) inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward)
@@ -257,7 +257,7 @@ struct ieee_binary_format<53> // binary64
These formats (float, double, and long double where it is binary64, e.g. These formats (float, double, and long double where it is binary64, e.g.
with MSVC or on Apple arm64) are converted by parse_float_native(). The with MSVC or on Apple arm64) are converted by parse_float_native(). The
predicate is the one the serializer uses to choose to_chars() over snprintf. predicate is the one the serializer uses to choose Grisu2.
*/ */
template<typename FloatType> template<typename FloatType>
struct has_native_float_format struct has_native_float_format
@@ -915,7 +915,7 @@ class binary_writer
JSON_THROW(out_of_range::create(exception_id::subtype_out_of_range, concat("subtype ", std::to_string(subtype), " is too large for ", what, " (max 255)"), &j)); JSON_THROW(out_of_range::create(exception_id::subtype_out_of_range, concat("subtype ", std::to_string(subtype), " is too large for ", what, " (max 255)"), &j));
} }
/// @throw other_error.502 always /// @throw other_error.407 always
JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE
static void throw_size_marker_required(const BasicJsonType& j) static void throw_size_marker_required(const BasicJsonType& j)
{ {
@@ -2033,9 +2033,8 @@ class serializer
} }
// If number_float_t is an IEEE-754 single or double precision number, // If number_float_t is an IEEE-754 single or double precision number,
// use to_chars() to produce short numbers which are guaranteed to // use the Grisu2 algorithm to produce short numbers which are
// round-trip, using strtof and strtod, resp. (the shortest digits of // guaranteed to round-trip, using strtof and strtod, resp.
// Zmij for binary64, the Grisu2 algorithm for binary32).
// //
// NB: The test below works if <long double> == <double>. // NB: The test below works if <long double> == <double>.
static constexpr bool is_ieee_single_or_double static constexpr bool is_ieee_single_or_double
+1 -1
View File
@@ -849,7 +849,7 @@ class basic_json_view
return !navigation::editable() || m_doc->edits == nullptr; return !navigation::editable() || m_doc->edits == nullptr;
} }
/// the member of this object with @a key (the first one if the key occurs more than once), or nullptr /// the member of this object with @a key (the last one if the key occurs more than once), or nullptr
NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const
{ {
return find_key(key, std::integral_constant<bool, is_editable> {}); return find_key(key, std::integral_constant<bool, is_editable> {});
+46 -30
View File
@@ -7810,30 +7810,47 @@ namespace detail
* leave j with the type of the new value, but the pointer to the destroyed old one. * leave j with the type of the new value, but the pointer to the destroyed old one.
*/ */
// a move iterator over the elements of an rvalue container, unless they are // reference type of the elements of a const T
// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a template<typename T>
// std::move_iterator as value_type&&, which cannot bind to a const element using const_range_reference_t = decltype(*std::declval<iterator_t<const T>&>());
template<typename Iterator>
std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/)
{
return std::make_move_iterator(it);
}
template<typename Iterator> // a container that owns its elements propagates constness to them (deep
Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/) // constness): the elements of a const std::vector<std::string> are const. A
{ // non-owning range (a span, an iterator range) has shallow constness: a const
return it; // span still gives mutable access to the elements it refers to. Moving from an
} // rvalue of such a range would empty the storage it refers to, so the elements
// of an rvalue range are only moved if it has deep constness.
template<typename T>
using owns_its_elements = std::is_const<typename std::remove_reference<detected_t<const_range_reference_t, T>>::type>;
template<typename Iterator> template<typename Iterator>
using is_mutable_iterator = std::integral_constant < bool, using is_mutable_iterator = std::integral_constant < bool,
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >; !std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
// a move iterator over the elements of an rvalue container that owns them,
// unless they are const (e.g., std::set): libstdc++ before GCC 5 defines the
// reference of a std::move_iterator as value_type&&, which cannot bind to a
// const element
template<typename Iterator> template<typename Iterator>
auto make_move_iterator_if_mutable(const Iterator& it) std::move_iterator<Iterator> make_move_iterator_if_impl(const Iterator& it, std::true_type /*move*/)
-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
{ {
return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}); return std::make_move_iterator(it);
}
template<typename Iterator>
Iterator make_move_iterator_if_impl(const Iterator& it, std::false_type /*move*/)
{
return it;
}
template<typename Container, typename Iterator>
using moves_elements = conjunction<owns_its_elements<Container>, is_mutable_iterator<Iterator>>;
template<typename Container, typename Iterator>
auto make_move_iterator_if_owned(const Iterator& it)
-> decltype(make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {}))
{
return make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {});
} }
template<value_t> struct external_constructor; template<value_t> struct external_constructor;
@@ -7955,14 +7972,14 @@ struct external_constructor<value_t::array>
j.replace_value(value_t::array, value); j.replace_value(value_t::array, value);
} }
/// an rvalue container: move its elements /// an rvalue container: move its elements if it owns them
template<typename BasicJsonType, typename CompatibleArrayType> template<typename BasicJsonType, typename CompatibleArrayType>
static void construct_moving(BasicJsonType& j, CompatibleArrayType& arr) static void construct_moving(BasicJsonType& j, CompatibleArrayType& arr)
{ {
using std::begin; using std::begin;
using std::end; using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr)))); const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_owned<CompatibleArrayType>(begin(arr)), make_move_iterator_if_owned<CompatibleArrayType>(end(arr))));
j.replace_value(value_t::array, value); j.replace_value(value_t::array, value);
} }
@@ -8016,14 +8033,14 @@ struct external_constructor<value_t::object>
j.replace_value(value_t::object, value); j.replace_value(value_t::object, value);
} }
/// an rvalue container: move its values /// an rvalue container: move its values if it owns them
template<typename BasicJsonType, typename CompatibleObjectType> template<typename BasicJsonType, typename CompatibleObjectType>
static void construct_moving(BasicJsonType& j, CompatibleObjectType& obj) static void construct_moving(BasicJsonType& j, CompatibleObjectType& obj)
{ {
using std::begin; using std::begin;
using std::end; using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj)))); const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_owned<CompatibleObjectType>(begin(obj)), make_move_iterator_if_owned<CompatibleObjectType>(end(obj))));
j.replace_value(value_t::object, value); j.replace_value(value_t::object, value);
} }
@@ -8218,7 +8235,8 @@ using is_rvalue_array_to_json = conjunction<is_movable_container_rvalue<T>,
is_compatible_string_type<BasicJsonType, T>, is_compatible_string_type<BasicJsonType, T>,
is_compatible_binary_type<BasicJsonType, T>>>>; is_compatible_binary_type<BasicJsonType, T>>>>;
// rvalue containers: their elements are moved instead of copied // rvalue containers: their elements are moved instead of copied if the
// container owns them (see owns_its_elements)
template<typename BasicJsonType, typename CompatibleArrayType, template<typename BasicJsonType, typename CompatibleArrayType,
enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0> enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0>
inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward) inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward)
@@ -11642,7 +11660,7 @@ struct ieee_binary_format<53> // binary64
These formats (float, double, and long double where it is binary64, e.g. These formats (float, double, and long double where it is binary64, e.g.
with MSVC or on Apple arm64) are converted by parse_float_native(). The with MSVC or on Apple arm64) are converted by parse_float_native(). The
predicate is the one the serializer uses to choose to_chars() over snprintf. predicate is the one the serializer uses to choose Grisu2.
*/ */
template<typename FloatType> template<typename FloatType>
struct has_native_float_format struct has_native_float_format
@@ -31147,7 +31165,7 @@ class binary_writer
JSON_THROW(out_of_range::create(exception_id::subtype_out_of_range, concat("subtype ", std::to_string(subtype), " is too large for ", what, " (max 255)"), &j)); JSON_THROW(out_of_range::create(exception_id::subtype_out_of_range, concat("subtype ", std::to_string(subtype), " is too large for ", what, " (max 255)"), &j));
} }
/// @throw other_error.502 always /// @throw other_error.407 always
JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE
static void throw_size_marker_required(const BasicJsonType& j) static void throw_size_marker_required(const BasicJsonType& j)
{ {
@@ -36006,11 +36024,10 @@ namespace detail
{ {
/*! /*!
@brief implements binary to decimal floating-point conversion: the shortest @brief implements the Grisu2 algorithm for binary to decimal floating-point
digits of Zmij (see zmij.hpp) for IEEE 754 binary64 numbers, and the Grisu2 conversion.
algorithm for all other formats.
The Grisu2 implementation is a slightly modified version of the reference This implementation is a slightly modified version of the reference
implementation which may be obtained from implementation which may be obtained from
http://florian.loitsch.com/publications (bench.tar.gz). http://florian.loitsch.com/publications (bench.tar.gz).
@@ -39520,9 +39537,8 @@ class serializer
} }
// If number_float_t is an IEEE-754 single or double precision number, // If number_float_t is an IEEE-754 single or double precision number,
// use to_chars() to produce short numbers which are guaranteed to // use the Grisu2 algorithm to produce short numbers which are
// round-trip, using strtof and strtod, resp. (the shortest digits of // guaranteed to round-trip, using strtof and strtod, resp.
// Zmij for binary64, the Grisu2 algorithm for binary32).
// //
// NB: The test below works if <long double> == <double>. // NB: The test below works if <long double> == <double>.
static constexpr bool is_ieee_single_or_double static constexpr bool is_ieee_single_or_double
+1 -1
View File
@@ -11016,7 +11016,7 @@ class basic_json_view
return !navigation::editable() || m_doc->edits == nullptr; return !navigation::editable() || m_doc->edits == nullptr;
} }
/// the member of this object with @a key (the first one if the key occurs more than once), or nullptr /// the member of this object with @a key (the last one if the key occurs more than once), or nullptr
NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const
{ {
return find_key(key, std::integral_constant<bool, is_editable> {}); return find_key(key, std::integral_constant<bool, is_editable> {});
+109
View File
@@ -67,6 +67,67 @@ void to_json(json& j, tracked&& t)
t.moved_from = true; t.moved_from = true;
} }
// non-owning range over contiguous storage (like gsl::span or a pre-C++20 span
// backport): its constness is shallow, so a const span gives mutable elements
template<typename T>
struct span_like
{
using value_type = T;
using iterator = T*;
using const_iterator = T*;
T* first;
T* last;
T* begin() const
{
return first;
}
T* end() const
{
return last;
}
};
// non-owning view of key/value pairs with key_type and mapped_type, so it is
// converted like an object
template<typename K, typename V>
struct map_span_like
{
using key_type = K;
using mapped_type = V;
using value_type = std::pair<const K, V>;
using iterator = value_type*;
using const_iterator = value_type*;
value_type* first;
value_type* last;
value_type* begin() const
{
return first;
}
value_type* end() const
{
return last;
}
};
// owning container that can only be iterated when it is not const
struct mutable_only_range
{
std::vector<std::string> values;
std::vector<std::string>::iterator begin()
{
return values.begin();
}
std::vector<std::string>::iterator end()
{
return values.end();
}
};
// user type with its own rvalue-aware serializer // user type with its own rvalue-aware serializer
struct udt_container struct udt_container
{ {
@@ -144,6 +205,34 @@ TEST_CASE("to_json from rvalue containers")
CHECK(tracked_moves == 2); CHECK(tracked_moves == 2);
} }
SECTION("tracked elements: standard containers move")
{
tracked_copies = 0;
tracked_moves = 0;
std::list<tracked> l;
l.emplace_back("l");
CHECK(json(std::move(l)) == json::array({"l"}));
std::deque<tracked> d;
d.emplace_back("d");
CHECK(json(std::move(d)) == json::array({"d"}));
std::forward_list<tracked> fl;
fl.emplace_front("f");
CHECK(json(std::move(fl)) == json::array({"f"}));
std::array<tracked, 1> a{{tracked("a")}};
CHECK(json(std::move(a)) == json::array({"a"}));
std::unordered_map<std::string, tracked> um;
um.emplace("k", tracked("u"));
CHECK(json(std::move(um)) == json({{"k", "u"}}));
CHECK(tracked_moves == 5);
CHECK(tracked_copies == 0);
}
SECTION("const rvalue is copied") SECTION("const rvalue is copied")
{ {
tracked_copies = 0; tracked_copies = 0;
@@ -221,6 +310,26 @@ TEST_CASE("to_json from rvalue containers")
CHECK(json(std::move(obj)) == json({{"a", 1}})); CHECK(json(std::move(obj)) == json({{"a", 1}}));
} }
SECTION("non-owning ranges are copied")
{
std::vector<std::string> v{long_a, long_b};
const json j = span_like<std::string> {v.data(), v.data() + v.size()};
CHECK(j == json::array({long_a, long_b}));
CHECK(v[0] == long_a);
CHECK(v[1] == long_b);
std::vector<std::pair<const std::string, std::string>> m{{"a", long_a}};
const json jm = map_span_like<std::string, std::string> {m.data(), m.data() + m.size()};
CHECK(jm == json({{"a", long_a}}));
CHECK(m[0].second == long_a);
// without a const begin(), it cannot be told whether the range owns
// its elements, so they are copied
mutable_only_range r{{long_a}};
CHECK(json(std::move(r)) == json::array({long_a}));
CHECK(r.values[0] == long_a); // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
}
SECTION("user type with its own to_json overloads") SECTION("user type with its own to_json overloads")
{ {
udt_container c{{1, 2}}; udt_container c{{1, 2}};