osrm-backend/include/util/json_deep_compare.hpp

#ifndef UTIL_JSON_DEEP_COMPARE_HPP
#define UTIL_JSON_DEEP_COMPARE_HPP

#include "util/integer_range.hpp"
#include "util/json_container.hpp"

#include <boost/assert.hpp>

#include <algorithm>
#include <functional>
#include <set>

namespace osrm::util::json
{

struct Comparator
{
    Comparator(std::string &reason_, const std::string &lhs_path_, const std::string &rhs_path_)
        : reason(reason_), lhs_path(lhs_path_), rhs_path(rhs_path_)
    {
    }

    bool operator()(const String &lhs, const String &rhs) const
    {
        bool is_same = lhs.value == rhs.value;
        if (!is_same)
        {
            reason = lhs_path + " (= \"" + lhs.value + "\") != " + rhs_path + " (= \"" + rhs.value +
                     "\")";
        }
        return is_same;
    }

    bool operator()(const Number &lhs, const Number &rhs) const
    {
        bool is_same = lhs.value == rhs.value;
        if (!is_same)
        {
            reason = lhs_path + " (= " + std::to_string(lhs.value) + ") != " + rhs_path +
                     " (= " + std::to_string(rhs.value) + ")";
        }
        return is_same;
    }

    bool operator()(const Object &lhs, const Object &rhs) const
    {
        std::set<std::string_view> lhs_keys;
        for (const auto &key_value : lhs.values)
        {
            lhs_keys.insert(key_value.first);
        }

        std::set<std::string_view> rhs_keys;
        for (const auto &key_value : rhs.values)
        {
            rhs_keys.insert(key_value.first);
        }

        for (const auto &key : lhs_keys)
        {
            if (rhs_keys.find(key) == rhs_keys.end())
            {
                reason = rhs_path + " doesn't have key \"" + std::string(key) + "\"";
                return false;
            }
        }

        for (const auto &key : rhs_keys)
        {
            if (lhs_keys.find(key) == lhs_keys.end())
            {
                reason = lhs_path + " doesn't have key \"" + std::string(key) + "\"";
                return false;
            }
        }

        for (const auto &key : lhs_keys)
        {
            BOOST_ASSERT(rhs.values.find(key) != rhs.values.end());
            BOOST_ASSERT(lhs.values.find(key) != lhs.values.end());

            const auto &rhs_child = rhs.values.find(key)->second;
            const auto &lhs_child = lhs.values.find(key)->second;
            auto is_same = std::visit(Comparator(reason,
                                                 lhs_path + "." + std::string(key),
                                                 rhs_path + "." + std::string(key)),
                                      lhs_child,
                                      rhs_child);
            if (!is_same)
            {
                return false;
            }
        }
        return true;
    }

    bool operator()(const Array &lhs, const Array &rhs) const
    {
        if (lhs.values.size() != rhs.values.size())
        {
            reason = lhs_path + ".length " + std::to_string(lhs.values.size()) + " != " + rhs_path +
                     ".length " + std::to_string(rhs.values.size());
            return false;
        }

        for (auto i = 0UL; i < lhs.values.size(); ++i)
        {
            auto is_same = std::visit(Comparator(reason,
                                                 lhs_path + "[" + std::to_string(i) + "]",
                                                 rhs_path + "[" + std::to_string(i) + "]"),
                                      lhs.values[i],
                                      rhs.values[i]);
            if (!is_same)
            {
                return false;
            }
        }

        return true;
    }

    bool operator()(const True &, const True &) const { return true; }
    bool operator()(const False &, const False &) const { return true; }
    bool operator()(const Null &, const Null &) const { return true; }

    bool operator()(const False &, const True &) const
    {
        reason = lhs_path + " is false but " + rhs_path + " is true";
        return false;
    }
    bool operator()(const True &, const False &) const
    {
        reason = lhs_path + " is true but " + rhs_path + " is false";
        return false;
    }

    template <typename T1,
              typename T2,
              typename = typename std::enable_if<!std::is_same<T1, T2>::value>::type>
    bool operator()(const T1 &, const T2 &)
    {
        reason = lhs_path + " and " + rhs_path + " have different types";
        return false;
    }

  private:
    std::string &reason;
    const std::string &lhs_path;
    const std::string &rhs_path;
};

inline bool compare(const Value &reference, const Value &result, std::string &reason)
{
    return std::visit(Comparator(reason, "reference", "result"), reference, result);
}
} // namespace osrm::util::json

#endif