// until C++20 bool operator>=(const_reference lhs, const_reference rhs) noexcept; // (1) template<typename ScalarType> bool operator>=(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2) template<typename ScalarType> bool operator>=(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
Compares whether one JSON value lhs is greater than or equal to another JSON value rhs according to the following rules:
false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.!(lhs < rhs) (see operator<).Compares whether a JSON value is greater than or equal to a scalar or a scalar is greater than or equal to a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType : a scalar type according to std::is_scalar<ScalarType>::value
lhs (in) : first value to consider
rhs (in) : second value to consider
whether lhs is greater than or equal to rhs
nullptr; the function is noexcept exactly in that case. Otherwise, it throws what the conversion throws, for example std::bad_alloc when converting a string, or out_of_range.410 for an enum value not mapped by NLOHMANN_JSON_SERIALIZE_ENUM_STRICT.Linear.
Comparing NaN
NaN values are unordered within the domain of numbers. The following comparisons all yield false:
NaN with itself.NaN with another NaN.NaN and any other number.Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
Deprecation
If JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON is defined to 1, the library declares a member bool operator>=(const_reference rhs) const noexcept in C++20 mode to emulate the legacy comparison of discarded values. This member is deprecated since version 3.11.0, together with the legacy comparison behavior.
See the migration guide for how to update existing code.
Example
The example demonstrates comparing several JSON types.
#include <iostream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
int main()
{
// create several JSON values
json array_1 = {1, 2, 3};
json array_2 = {1, 2, 4};
json object_1 = {{"A", "a"}, {"B", "b"}};
json object_2 = {{"B", "b"}, {"A", "a"}};
json number_1 = 17;
json number_2 = 17.0000000000001L;
json string_1 = "foo";
json string_2 = "bar";
// output values and comparisons
std::cout << std::boolalpha;
std::cout << array_1 << " >= " << array_2 << " " << (array_1 >= array_2) << '\n';
std::cout << object_1 << " >= " << object_2 << " " << (object_1 >= object_2) << '\n';
std::cout << number_1 << " >= " << number_2 << " " << (number_1 >= number_2) << '\n';
std::cout << string_1 << " >= " << string_2 << " " << (string_1 >= string_2) << '\n';
}
Output:
[1,2,3] >= [1,2,4] false
{"A":"a","B":"b"} >= {"A":"a","B":"b"} true
17 >= 17.0000000000001 false
"foo" >= "bar" true
noexcept in version 3.13.0 unreleased; before, a throwing conversion called std::terminate.