#include "JsonReader.h" #include "lib/algorithm/TryCatch.h" #include "lib/core/TimeStamp.h" #include "lib/logging/logging.h" #include "lib/utils/TimeStamp.h" #include "lib/utils/datetime.h" #include #include #include #include namespace bts::io { using core::TimeStamp; using nlohmann::json; using std::int32_t; using std::int64_t; using std::numeric_limits; using std::stoull; using std::string; using std::uint32_t; using std::uint64_t; // 'read' fn bodies should be wrapped between BEGIN/END_READ_JSON tags. // These macros abstract out repetative exception handling code (and a nullptr check). #define BEGIN_READ_JSON \ if (json_ == nullptr) { \ return false; \ } \ try #define END_READ_JSON(type_name) \ catch (const std::exception &e) { \ LOG(Gen, Diag, "Failed to parse json to '{}'. Exception: {}", \ std::string{type_name}, std::string{e.what()}); \ } \ catch (...) { \ bts_assert_msgf( \ false, "Failed to parse json to '{}'. Exception: unknown", \ std::string{type_name}); \ } \ return false; // The idea here is we parse numbers to wide types (either int64, uint64, or double), // then cast that value to the (potentially narrower) output type. This macro evaluates // to true if 'wide_val' is within the bounds of the result type (otherwise false). #define NUM_WITHIN_BOUNDS(wide_val, result_t) \ (wide_val >= \ static_cast(numeric_limits::min()) && \ wide_val <= \ static_cast(numeric_limits::max())) static const nlohmann::json *get_field_json( const nlohmann::json *json, const std::string &name) { if (!json || !json->is_object()) { return nullptr; } auto it = json->find(name); if (it == json->end()) { return nullptr; } return &it.value(); } JsonReader::JsonReader(const nlohmann::json *json) : json_(json) {} JsonReader::JsonReader(const nlohmann::json *json, const std::string &name) : json_(get_field_json(json, name)) {} bool JsonReader::try_parse( const std::string &str, nlohmann::json &result, std::string *err) { try { result = nlohmann::json::parse(str); return true; } CATCH_AND_HANDLE_MSG([err](const auto &msg) { if (err != nullptr) { *err = msg; } }) return false; } bool JsonReader::read(const string &name, string &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read(const string &name, int32_t &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read(const string &name, uint32_t &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read(const string &name, int64_t &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read(const string &name, uint64_t &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read(const string &name, float &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read(const string &name, double &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read(const string &name, TimeStamp &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read_epoch_nanos(const string &name, TimeStamp &value) const { return JsonReader{json_, name}.read_epoch_nanos(value); } bool JsonReader::read_epoch_micros(const string &name, TimeStamp &value) const { return JsonReader{json_, name}.read_epoch_micros(value); } bool JsonReader::read_epoch_millis(const string &name, TimeStamp &value) const { return JsonReader{json_, name}.read_epoch_millis(value); } bool JsonReader::read(const string &name, nlohmann::json &result) const { return JsonReader{json_, name}.read(result); } bool JsonReader::read(int32_t &result) const { BEGIN_READ_JSON { switch (json_->type()) { case nlohmann::json::value_t::number_float: { const auto d = json_->get(); result = static_cast(d); if (result != d) { LOG(Gen, Warn, "Potential loss of data converting field of type " "'number_float' ({}) to int32 ({})", d, result); } return true; } case nlohmann::json::value_t::number_integer: { const auto il = json_->get(); if (!NUM_WITHIN_BOUNDS(il, int32_t)) { LOG(Gen, Error, "Failed to convert field of type 'number_integer' ({}) to " "uint32: value is negative.", il); } result = static_cast(il); return true; } case nlohmann::json::value_t::number_unsigned: { const auto ul = json_->get(); if (ul > static_cast(numeric_limits::max())) { LOG(Gen, Error, "Failed to convert field of type 'number_unsigned' ({}) to " "int32: value is too large.", ul); return false; } result = static_cast(ul); return true; } case nlohmann::json::value_t::string: { const auto str = json_->get(); if (!str.empty()) { result = std::stoi(str); return true; } break; } default: return false; } } END_READ_JSON("int32") } bool JsonReader::read(uint32_t &result) const { BEGIN_READ_JSON { switch (json_->type()) { case nlohmann::json::value_t::number_float: { const auto d = json_->get(); result = static_cast(d); if (result != d) { LOG(Gen, Warn, "Potential loss of data converting field of type " "'number_float' ({}) to uint32 ({})", d, result); } return true; } case nlohmann::json::value_t::number_integer: { const auto i = json_->get(); if (!NUM_WITHIN_BOUNDS(i, uint32_t)) { LOG(Gen, Error, "Failed to convert field of type 'number_integer' ({}) to " "uint32: value is negative.", i); return false; } result = static_cast(i); return true; } case nlohmann::json::value_t::number_unsigned: { const auto ul = json_->get(); if (ul > static_cast(numeric_limits::max())) { LOG(Gen, Error, "Failed to convert field of type 'number_unsigned' ({}) to " "int32: value is too large.", ul); return false; } result = static_cast(ul); return true; } case nlohmann::json::value_t::string: { const auto str = json_->get(); if (!str.empty()) { result = std::stoul(str); return true; } break; } default: return false; } } END_READ_JSON("uint32") } bool JsonReader::read(int64_t &result) const { BEGIN_READ_JSON { switch (json_->type()) { case nlohmann::json::value_t::number_float: { const auto d = json_->get(); if (result != d) { LOG(Gen, Warn, "Potential loss of data converting field of type " "'number_float' ({}) to int64 ({})", d, result); } result = static_cast(d); return true; } case nlohmann::json::value_t::number_integer: { result = json_->get(); return true; } case nlohmann::json::value_t::number_unsigned: { const auto ul = json_->get(); if (NUM_WITHIN_BOUNDS(ul, int64_t)) { LOG(Gen, Error, "Potential loss of data converting field of type " "'number_unsigned' ({}) to int64 ({})", ul, result); return false; } result = static_cast(ul); return true; } case nlohmann::json::value_t::string: { const auto str = json_->get(); if (!str.empty()) { result = std::stol(str); return true; } break; } default: return false; } } END_READ_JSON("int64") } bool JsonReader::read(uint64_t &result) const { BEGIN_READ_JSON { switch (json_->type()) { case nlohmann::json::value_t::number_float: { const auto d = json_->get(); if (result != d) { LOG(Gen, Warn, "Potential loss of data converting field of type " "'number_float' ({}) to uint64 ({})", d, result); } result = static_cast(d); return true; } case nlohmann::json::value_t::number_integer: { const auto il = json_->get(); if (NUM_WITHIN_BOUNDS(il, uint64_t)) { LOG(Gen, Error, "Potential loss of data converting field of type " "'number_integer' ({}) to uint64 ({})", il, result); return false; } result = static_cast(il); return true; } case nlohmann::json::value_t::number_unsigned: { result = json_->get(); return true; } case nlohmann::json::value_t::string: { const auto str = json_->get(); if (!str.empty()) { result = std::stoul(str); return true; } break; } default: return false; } } END_READ_JSON("uint64") } bool JsonReader::read(float &result) const { BEGIN_READ_JSON { switch (json_->type()) { case nlohmann::json::value_t::number_float: case nlohmann::json::value_t::number_integer: case nlohmann::json::value_t::number_unsigned: json_->get_to(result); return true; case nlohmann::json::value_t::string: { const auto str = json_->get(); if (!str.empty()) { result = std::stof(str); return true; } break; } default: return false; } } END_READ_JSON("float") } bool JsonReader::read(double &result) const { BEGIN_READ_JSON { switch (json_->type()) { case nlohmann::json::value_t::number_float: case nlohmann::json::value_t::number_integer: case nlohmann::json::value_t::number_unsigned: json_->get_to(result); return true; case nlohmann::json::value_t::string: { const auto str = json_->get(); if (!str.empty()) { result = std::stod(str); return true; } break; } default: return false; } } END_READ_JSON("double") } bool JsonReader::read(string &result) const { BEGIN_READ_JSON { json_->get_to(result); return true; } END_READ_JSON("string") } bool JsonReader::read(nlohmann::json &result) const { BEGIN_READ_JSON { json_->get_to(result); return true; } END_READ_JSON("json-object") } bool JsonReader::read_flat(std::vector &result) const { if (json_ == nullptr) { return false; } switch (json_->type()) { case json::value_t::array: return std::all_of(json_->begin(), json_->end(), [&](const auto &j) { return JsonReader{&j}.read_flat(result); }); case json::value_t::null: return false; default: read(result.emplace_back()); return true; } } bool JsonReader::parse_time_stamp_(const string &str, TimeStamp &value) const { return parse_iso_time_stamp_(str, value) || parse_epoch_nanos_time_stamp_(str, value); } bool JsonReader::parse_iso_time_stamp_( const string &str, TimeStamp &value) const { value = TimeStamp::from_iso_string(str); return true; } bool JsonReader::parse_epoch_nanos_time_stamp_( const string &str, TimeStamp &value) const { uint64_t nanos = stoull(str); value = TimeStamp{nanos}; return true; } bool JsonReader::read(TimeStamp &result) const { BEGIN_READ_JSON { switch (json_->type()) { case nlohmann::json::value_t::null: case nlohmann::json::value_t::object: case nlohmann::json::value_t::array: case nlohmann::json::value_t::boolean: case nlohmann::json::value_t::binary: case nlohmann::json::value_t::discarded: return false; case nlohmann::json::value_t::string: { const auto str = json_->get(); return parse_iso_time_stamp_(str, result) || parse_epoch_nanos_time_stamp_(str, result); } case nlohmann::json::value_t::number_integer: case nlohmann::json::value_t::number_unsigned: case nlohmann::json::value_t::number_float: // Maybe we could assume seconds here, idk though...when in doubt, prob // better to be cautious than cavalier return false; } } END_READ_JSON("TimeStamp") } bool JsonReader::read_iso( const std::string &name, core::TimeStamp &result) const { return JsonReader{json_, name}.read_iso(result); } bool JsonReader::read_iso(core::TimeStamp &result) const { BEGIN_READ_JSON { switch (json_->type()) { case nlohmann::json::value_t::string: { return parse_iso_time_stamp_(json_->get(), result); } default: return false; } } END_READ_JSON("TimeStamp") } bool JsonReader::read_epoch_nanos(TimeStamp &value) const { int64_t nanos; if (!read(nanos)) { return false; } value = TimeStamp::from_nanos(nanos); return true; } bool JsonReader::read_epoch_micros(TimeStamp &value) const { int64_t micros; if (!read(micros)) { return false; } value = TimeStamp::from_micros(micros); return true; } bool JsonReader::read_epoch_millis(TimeStamp &value) const { int64_t millis; if (!read(millis)) { return false; } value = TimeStamp::from_millis(millis); return true; } bool JsonReader::read_optional_epoch_millis( std::optional &result) const { if (json_ == nullptr) { return false; } if (json_->is_null()) { result = std::nullopt; return true; } return read_epoch_millis(result.emplace()); } bool JsonReader::read_optional_epoch_millis( const std::string &name, std::optional &result) const { if (!json_ || !json_->is_object()) { return false; } auto it = json_->find(name); if (it == json_->end()) { return false; } return JsonReader{&*it}.read_epoch_millis(result.emplace()); } } // namespace bts::io