operator== [3/3]

template<template< typename U, typename V, typename... Args > class ObjectType = std::map, template< typename U, typename... Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator, template< typename T, typename SFINAE=void > class JSONSerializer = adl_serializer, class BinaryType = std::vector<std::uint8_t>>

template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>

bool operator== ( ScalarType  lhs, const_reference  rhs  )

friend

comparison: equal

comparison: equal

Compares two JSON values for equality according to the following rules:

• Two JSON values are equal if (1) they are from the same type and (2) their stored values are the same according to their respective operator==.
• Integer and floating-point numbers are automatically converted before comparison. Note that two NaN values are always treated as unequal.
• Two JSON null values are equal.

Note

Floating-point inside JSON values numbers are compared with json::number_float_t::operator== which is double::operator== by default. To compare floating-point while respecting an epsilon, an alternative comparison function could be used, for instance

template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
{
    return std::abs(a - b) <= epsilon;
}

Or you can self-defined operator equal function like this:

bool my_equal(const_reference lhs, const_reference rhs) {
const auto lhs_type lhs.type();
const auto rhs_type rhs.type();
if (lhs_type == rhs_type) {
    switch(lhs_type)
        // self_defined case
        case value_t::number_float:
            return std::abs(lhs - rhs) <= std::numeric_limits<float>::epsilon();
        // other cases remain the same with the original
        ...
}
...
}

NaN values never compare equal to themselves or to other NaN values.

Parameters

[in]	lhs	first JSON value to consider
[in]	rhs	second JSON value to consider

Returns

whether the values lhs and rhs are equal

@exceptionsafety No-throw guarantee: this function never throws exceptions.

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__equal}

Since

version 1.0.0

Definition at line 24159 of file json.hpp.

    {
        return basic_json(lhs) == rhs;
    }