Skip to content

Commit

Permalink
Try to get rid of std::variant in json_container.hpp
Browse files Browse the repository at this point in the history
  • Loading branch information
@SiarheiFedartsou
SiarheiFedartsou committed Sep 28, 2024
1 parent 150c792 commit feb8da2
Show file tree
Hide file tree
Showing 6 changed files with 410 additions and 401 deletions.
7 changes: 7 additions & 0 deletions include/util/json_container.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -207,6 +207,13 @@ get<osrm::util::json::Object>(const osrm::util::json::Value &value) noexcept
return value.object;
}

template <>
inline const osrm::util::json::Array &
get<osrm::util::json::Array>(const osrm::util::json::Value &value) noexcept
{
return value.array;
}

template <typename Visitor>
inline void visit(Visitor &&visitor, const osrm::util::json::Value &value)
{
Expand Down
316 changes: 159 additions & 157 deletions include/util/json_deep_compare.hpp
View file
Original file line number Diff line number Diff line change
@@ -1,157 +1,159 @@
#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> lhs_keys;
for (const auto &key_value : lhs.values)
{
lhs_keys.insert(key_value.first);
}

std::set<std::string> 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 \"" + key + "\"";
return false;
}
}

for (const auto &key : rhs_keys)
{
if (lhs_keys.find(key) == lhs_keys.end())
{
reason = lhs_path + " doesn't have key \"" + 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 + "." + key, rhs_path + "." + 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
// #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> lhs_keys;
// for (const auto &key_value : lhs.values)
// {
// lhs_keys.insert(key_value.first);
// }

// std::set<std::string> 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 \"" + key + "\"";
// return false;
// }
// }

// for (const auto &key : rhs_keys)
// {
// if (lhs_keys.find(key) == lhs_keys.end())
// {
// reason = lhs_path + " doesn't have key \"" + 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 + "." + key, rhs_path + "." + 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
40 changes: 20 additions & 20 deletions unit_tests/library/equal_json.hpp
View file
Original file line number Diff line number Diff line change
@@ -1,28 +1,28 @@
#ifndef UNIT_TESTS_JSON_EQUAL
#define UNIT_TESTS_JSON_EQUAL
// #ifndef UNIT_TESTS_JSON_EQUAL
// #define UNIT_TESTS_JSON_EQUAL

#include <boost/test/unit_test.hpp>
// #include <boost/test/unit_test.hpp>

#include "osrm/json_container.hpp"
#include "util/json_deep_compare.hpp"
// #include "osrm/json_container.hpp"
// #include "util/json_deep_compare.hpp"

inline boost::test_tools::predicate_result compareJSON(const osrm::util::json::Value &reference,
const osrm::util::json::Value &result)
{
std::string reason;
auto is_same = osrm::util::json::compare(reference, result, reason);
if (!is_same)
{
boost::test_tools::predicate_result res(false);
// inline boost::test_tools::predicate_result compareJSON(const osrm::util::json::Value &reference,
// const osrm::util::json::Value &result)
// {
// std::string reason;
// auto is_same = osrm::util::json::compare(reference, result, reason);
// if (!is_same)
// {
// boost::test_tools::predicate_result res(false);

res.message() << reason;
// res.message() << reason;

return res;
}
// return res;
// }

return true;
}
// return true;
// }

#define CHECK_EQUAL_JSON(reference, result) BOOST_CHECK(compareJSON(reference, result));
// #define CHECK_EQUAL_JSON(reference, result) BOOST_CHECK(compareJSON(reference, result));

#endif
// #endif
Loading

0 comments on commit feb8da2

Please sign in to comment.