diff --git a/3rdparty/include/meojson/json.h b/3rdparty/include/meojson/json.h deleted file mode 100644 index e3b07a49e7..0000000000 --- a/3rdparty/include/meojson/json.h +++ /dev/null @@ -1,7 +0,0 @@ -#pragma once - -#include "json_parser.h" -#include "json_value.h" -#include "json_object.h" -#include "json_array.h" -#include "json_exception.h" \ No newline at end of file diff --git a/3rdparty/include/meojson/json.hpp b/3rdparty/include/meojson/json.hpp new file mode 100644 index 0000000000..7759d2fd76 --- /dev/null +++ b/3rdparty/include/meojson/json.hpp @@ -0,0 +1,1953 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#define MEOJSON_INLINE inline + +namespace json +{ + // ************************* + // * exception declare * + // ************************* + class exception : public std::exception + { + public: + exception() = default; + exception(const std::string& msg) : m_msg(msg) {} + + exception(const exception&) = default; + exception& operator=(const exception&) = default; + exception(exception&&) = default; + exception& operator=(exception&&) = default; + + virtual ~exception() noexcept override = default; + + virtual const char* what() const noexcept override { return m_msg.c_str(); } + + private: + std::string m_msg; + }; + + class array; + class object; + + // ************************* + // * value declare * + // ************************* + enum class value_type : char + { + Invalid, + Null, + Boolean, + String, + Number, + Array, + Object, + NUM_T + }; + + class value + { + using unique_array = std::unique_ptr; + using unique_object = std::unique_ptr; + + public: + value(); + value(const value& rhs); + value(value&& rhs) noexcept; + + value(bool b); + + value(int num); + value(unsigned num); + value(long num); + value(unsigned long num); + value(long long num); + value(unsigned long long num); + value(float num); + value(double num); + value(long double num); + + value(const char* str); + value(const std::string& str); + value(std::string&& str); + + value(const array& arr); + value(array&& arr); + // value(std::initializer_list init_list); // for array + + value(const object& obj); + value(object&& obj); + // error: conversion from ‘’ to ‘value’ + // is ambiguous value(std::initializer_list> + // init_list); // for object + + // Constructed from raw data + template value(value_type type, Args &&...args); + + // Prohibit conversion of other types to value + template value(T) = delete; + + ~value(); + + bool valid() const noexcept + { + return _type != value_type::Invalid ? true : false; + } + bool empty() const noexcept + { + return (_type == value_type::Null && _raw_data.compare("null") == 0) + ? true + : false; + } + bool is_null() const noexcept { return empty(); } + bool is_number() const noexcept { return _type == value_type::Number; } + bool is_boolean() const noexcept { return _type == value_type::Boolean; } + bool is_string() const noexcept { return _type == value_type::String; } + bool is_array() const noexcept { return _type == value_type::Array; } + bool is_object() const noexcept { return _type == value_type::Object; } + bool exist(const std::string& key) const; + bool exist(size_t pos) const; + value_type type() const noexcept { return _type; } + const value& at(size_t pos) const; + const value& at(const std::string& key) const; + + template + auto get(const std::string& key, const Type& default_value) const; + + template + auto get(size_t pos, const Type& default_value) const; + + const bool as_boolean() const; + const int as_integer() const; + // const unsigned as_unsigned() const; + const long as_long() const; + const unsigned long as_unsigned_long() const; + const long long as_long_long() const; + const unsigned long long as_unsigned_long_long() const; + const float as_float() const; + const double as_double() const; + const long double as_long_double() const; + const std::string as_string() const; + const array& as_array() const; + const object& as_object() const; + + array& as_array(); + object& as_object(); + + // return raw string + const std::string to_string() const; + const std::string format(std::string shift_str = " ", + size_t basic_shift_count = 0) const; + + value& operator=(const value& rhs); + value& operator=(value&&) noexcept; + + const value& operator[](size_t pos) const; + value& operator[](size_t pos); + value& operator[](const std::string& key); + value& operator[](std::string&& key); + // explicit operator bool() const noexcept { return valid(); } + + explicit operator bool() const { return as_boolean(); } + explicit operator int() const { return as_integer(); } + explicit operator long() const { return as_long(); } + explicit operator unsigned long() const { return as_unsigned_long(); } + explicit operator long long() const { return as_long_long(); } + explicit operator unsigned long long() const + { + return as_unsigned_long_long(); + } + explicit operator float() const { return as_float(); } + explicit operator double() const { return as_double(); } + explicit operator long double() const { return as_long_double(); } + explicit operator std::string() const { return as_string(); } + + private: + template + static std::unique_ptr copy_unique_ptr(const std::unique_ptr& t) + { + return t == nullptr ? nullptr : std::make_unique(*t); + } + + value_type _type = value_type::Null; + std::string _raw_data = "null"; // If the value_type is Object or Array, the + // _raw_data will be a empty string. + unique_array _array_ptr; + unique_object _object_ptr; + }; + + const value invalid_value(); + + // ************************* + // * array declare * + // ************************* + class array + { + public: + using raw_array = std::vector; + using iterator = raw_array::iterator; + using const_iterator = raw_array::const_iterator; + using reverse_iterator = raw_array::reverse_iterator; + using const_reverse_iterator = raw_array::const_reverse_iterator; + + array() = default; + array(const array& rhs) = default; + array(array&& rhs) noexcept = default; + array(const raw_array& arr); + array(raw_array&& arr) noexcept; + array(std::initializer_list init_list); + + template array(ArrayType arr); + + ~array() noexcept = default; + + bool empty() const noexcept { return _array_data.empty(); } + size_t size() const noexcept { return _array_data.size(); } + bool exist(size_t pos) const { return _array_data.size() < pos; } + const value& at(size_t pos) const; + const std::string to_string() const; + const std::string format(std::string shift_str = " ", + size_t basic_shift_count = 0) const; + + const bool get(size_t pos, bool default_value) const; + const int get(size_t pos, int default_value) const; + const long get(size_t pos, long default_value) const; + const unsigned long get(size_t pos, unsigned default_value) const; + const long long get(size_t pos, long long default_value) const; + const unsigned long long get(size_t pos, + unsigned long long default_value) const; + const float get(size_t pos, float default_value) const; + const double get(size_t pos, double default_value) const; + const long double get(size_t pos, long double default_value) const; + const std::string get(size_t pos, std::string default_value) const; + const std::string get(size_t pos, const char* default_value) const; + + template decltype(auto) emplace_back(Args &&...args); + + void clear() noexcept; + // void earse(size_t pos); + + iterator begin() noexcept; + iterator end() noexcept; + const_iterator begin() const noexcept; + const_iterator end() const noexcept; + const_iterator cbegin() const noexcept; + const_iterator cend() const noexcept; + + reverse_iterator rbegin() noexcept; + reverse_iterator rend() noexcept; + const_reverse_iterator rbegin() const noexcept; + const_reverse_iterator rend() const noexcept; + const_reverse_iterator crbegin() const noexcept; + const_reverse_iterator crend() const noexcept; + + const value& operator[](size_t pos) const; + value& operator[](size_t pos); + + array& operator=(const array&) = default; + array& operator=(array&&) noexcept = default; + + // const raw_array &raw_data() const; + + private: + raw_array _array_data; + }; + + // ************************* + // * object declare * + // ************************* + class object + { + public: + using raw_object = std::unordered_map; + using iterator = raw_object::iterator; + using const_iterator = raw_object::const_iterator; + + object() = default; + object(const object& rhs) = default; + object(object&& rhs) = default; + object(const raw_object& raw_obj); + object(raw_object&& raw_obj); + object(std::initializer_list init_list); + template object(MapType map); + + ~object() = default; + + bool empty() const noexcept { return _object_data.empty(); } + size_t size() const noexcept { return _object_data.size(); } + bool exist(const std::string& key) const + { + return _object_data.find(key) != _object_data.cend(); + } + const value& at(const std::string& key) const; + const std::string to_string() const; + const std::string format(std::string shift_str = " ", + size_t basic_shift_count = 0) const; + + const bool get(const std::string& key, bool default_value) const; + const int get(const std::string& key, int default_value) const; + const long get(const std::string& key, long default_value) const; + const unsigned long get(const std::string& key, unsigned default_value) const; + const long long get(const std::string& key, long long default_value) const; + const unsigned long long get(const std::string& key, + unsigned long long default_value) const; + const float get(const std::string& key, float default_value) const; + const double get(const std::string& key, double default_value) const; + const long double get(const std::string& key, + long double default_value) const; + const std::string get(const std::string& key, + std::string default_value) const; + const std::string get(const std::string& key, + const char* default_value) const; + + template decltype(auto) emplace(Args &&...args); + + void clear() noexcept; + bool earse(const std::string& key); + + iterator begin() noexcept; + iterator end() noexcept; + const_iterator begin() const noexcept; + const_iterator end() const noexcept; + const_iterator cbegin() const noexcept; + const_iterator cend() const noexcept; + + value& operator[](const std::string& key); + value& operator[](std::string&& key); + + object& operator=(const object&) = default; + object& operator=(object&&) = default; + + // const raw_object &raw_data() const; + + private: + raw_object _object_data; + }; + + // ************************* + // * aux declare * + // ************************* + + inline std::string unescape_string(std::string str) + { + for (size_t pos = 0; pos < str.size(); ++pos) { + std::string replace_str; + switch (str[pos]) { + case '\"': + replace_str = R"(\")"; + break; + case '\\': + replace_str = R"(\\)"; + break; + case '\b': + replace_str = R"(\b)"; + break; + case '\f': + replace_str = R"(\f)"; + break; + case '\n': + replace_str = R"(\n)"; + break; + case '\r': + replace_str = R"(\r)"; + break; + case '\t': + replace_str = R"(\t)"; + break; + default: + continue; + break; + } + str.replace(pos, replace_str.size(), replace_str); + ++pos; + } + return str; + } + + inline std::string escape_string(std::string str) + { + for (size_t pos = 0; pos + 1 < str.size(); ++pos) { + if (str[pos] != '\\') { + continue; + } + std::string replace_str; + switch (str[pos + 1]) { + case '"': + replace_str = "\""; + break; + case '\\': + replace_str = "\\"; + break; + case 'b': + replace_str = "\b"; + break; + case 'f': + replace_str = "\f"; + break; + case 'n': + replace_str = "\n"; + break; + case 'r': + replace_str = "\r"; + break; + case 't': + replace_str = "\t"; + break; + default: + return std::string(); + break; + } + str.replace(pos, replace_str.size(), replace_str); + } + return str; + } + + enum class value_type : char; + + // ************************* + // * array impl * + // ************************* + template decltype(auto) array::emplace_back(Args &&...args) + { + static_assert(std::is_constructible::value, + "Parameter can't be used to construct a raw_array::value_type"); + return _array_data.emplace_back(std::forward(args)...); + } + + MEOJSON_INLINE array::array(const raw_array& arr) : _array_data(arr) { ; } + + MEOJSON_INLINE array::array(raw_array&& arr) noexcept + : _array_data(std::move(arr)) + { + ; + } + + MEOJSON_INLINE + array::array(std::initializer_list init_list) + : _array_data(init_list) + { + ; + } + + template + MEOJSON_INLINE array::array(ArrayType arr) + { + static_assert( + std::is_constructible::value, + "Parameter can't be used to construct a json::value"); + for (auto&& ele : arr) { + _array_data.emplace_back(std::move(ele)); + } + } + + MEOJSON_INLINE const value& array::at(size_t pos) const + { + return _array_data.at(pos); + } + + MEOJSON_INLINE void array::clear() noexcept { _array_data.clear(); } + + MEOJSON_INLINE const std::string array::to_string() const + { + std::string str = "["; + for (const value& val : _array_data) { + str += val.to_string() + ","; + } + if (str.back() == ',') { + str.pop_back(); + } + str += "]"; + return str; + } + + MEOJSON_INLINE const std::string array::format(std::string shift_str, + size_t basic_shift_count) const + { + std::string shift; + for (size_t i = 0; i != basic_shift_count + 1; ++i) { + shift += shift_str; + } + + std::string str = "["; + for (const value& val : _array_data) { + str += "\n" + shift + val.format(shift_str, basic_shift_count + 1) + ","; + } + if (str.back() == ',') { + str.pop_back(); // pop last ',' + } + + str += '\n'; + for (size_t i = 0; i != basic_shift_count; ++i) { + str += shift_str; + } + str += ']'; + return str; + } + + MEOJSON_INLINE const bool array::get(size_t pos, bool default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_boolean()) { + return value.as_boolean(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const int array::get(size_t pos, int default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_number()) { + return value.as_integer(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const long array::get(size_t pos, long default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_number()) { + return value.as_long(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const unsigned long array::get(size_t pos, + unsigned default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_number()) { + return value.as_unsigned_long(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const long long array::get(size_t pos, + long long default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_number()) { + return value.as_long_long(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const unsigned long long + array::get(size_t pos, unsigned long long default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_number()) { + return value.as_unsigned_long_long(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const float array::get(size_t pos, float default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_number()) { + return value.as_float(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const double array::get(size_t pos, double default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_number()) { + return value.as_double(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const long double array::get(size_t pos, + long double default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_number()) { + return value.as_long_double(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const std::string array::get(size_t pos, + std::string default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_string()) { + return value.as_string(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const std::string array::get(size_t pos, + const char* default_value) const + { + if (exist(pos)) { + value value = _array_data.at(pos); + if (value.is_string()) { + return value.as_string(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE array::iterator array::begin() noexcept + { + return _array_data.begin(); + } + + MEOJSON_INLINE array::iterator array::end() noexcept + { + return _array_data.end(); + } + + MEOJSON_INLINE array::const_iterator array::begin() const noexcept + { + return _array_data.begin(); + } + + MEOJSON_INLINE array::const_iterator array::end() const noexcept + { + return _array_data.end(); + } + + MEOJSON_INLINE array::const_iterator array::cbegin() const noexcept + { + return _array_data.cbegin(); + } + + MEOJSON_INLINE array::const_iterator array::cend() const noexcept + { + return _array_data.cend(); + } + + MEOJSON_INLINE array::reverse_iterator array::rbegin() noexcept + { + return _array_data.rbegin(); + } + + MEOJSON_INLINE array::reverse_iterator array::rend() noexcept + { + return _array_data.rend(); + } + + MEOJSON_INLINE array::const_reverse_iterator array::rbegin() const noexcept + { + return _array_data.rbegin(); + } + + MEOJSON_INLINE array::const_reverse_iterator array::rend() const noexcept + { + return _array_data.rend(); + } + + MEOJSON_INLINE array::const_reverse_iterator array::crbegin() const noexcept + { + return _array_data.crbegin(); + } + + MEOJSON_INLINE array::const_reverse_iterator array::crend() const noexcept + { + return _array_data.crend(); + } + + MEOJSON_INLINE value& array::operator[](size_t pos) { return _array_data[pos]; } + + MEOJSON_INLINE const value& array::operator[](size_t pos) const + { + return _array_data[pos]; + } + + // const raw_array &array::raw_data() const + // { + // return _array_data; + // } + + // ************************* + // * object impl * + // ************************* + template decltype(auto) object::emplace(Args &&...args) + { + static_assert( + std::is_constructible::value, + "Parameter can't be used to construct a raw_object::value_type"); + return _object_data.emplace(std::forward(args)...); + } + + MEOJSON_INLINE std::ostream& operator<<(std::ostream& out, const array& arr) + { + // TODO: format output + + out << arr.to_string(); + return out; + } + + MEOJSON_INLINE object::object(const raw_object& raw_obj) + : _object_data(raw_obj) + { + ; + } + + MEOJSON_INLINE object::object(raw_object&& raw_obj) + : _object_data(std::move(raw_obj)) + { + ; + } + + MEOJSON_INLINE + object::object(std::initializer_list init_list) + { + for (const auto& [key, val] : init_list) { + emplace(key, val); + } + } + + MEOJSON_INLINE const value& object::at(const std::string& key) const + { + return _object_data.at(key); + } + + MEOJSON_INLINE void object::clear() noexcept { _object_data.clear(); } + + MEOJSON_INLINE bool object::earse(const std::string& key) + { + return _object_data.erase(key) > 0 ? true : false; + } + + MEOJSON_INLINE const std::string object::to_string() const + { + std::string str = "{"; + for (const auto& [key, val] : _object_data) { + str += "\"" + unescape_string(key) + "\":" + val.to_string() + ","; + } + if (str.back() == ',') { + str.pop_back(); + } + str += "}"; + return str; + } + + MEOJSON_INLINE const std::string + object::format(std::string shift_str, size_t basic_shift_count) const + { + std::string shift; + for (size_t i = 0; i != basic_shift_count + 1; ++i) { + shift += shift_str; + } + + std::string str = "{"; + for (const auto& [key, val] : _object_data) { + str += "\n" + shift + "\"" + unescape_string(key) + + "\": " + val.format(shift_str, basic_shift_count + 1) + ","; + } + if (str.back() == ',') { + str.pop_back(); // pop last ',' + } + + str += '\n'; + for (size_t i = 0; i != basic_shift_count; ++i) { + str += shift_str; + } + str += '}'; + return str; + } + + MEOJSON_INLINE const bool object::get(const std::string& key, + bool default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_boolean()) { + return value.as_boolean(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const int object::get(const std::string& key, + int default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_number()) { + return value.as_integer(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const long object::get(const std::string& key, + long default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_number()) { + return value.as_long(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const unsigned long object::get(const std::string& key, + unsigned default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_number()) { + return value.as_unsigned_long(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const long long object::get(const std::string& key, + long long default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_number()) { + return value.as_long_long(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const unsigned long long + object::get(const std::string& key, unsigned long long default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_number()) { + return value.as_unsigned_long_long(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const float object::get(const std::string& key, + float default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_number()) { + return value.as_float(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const double object::get(const std::string& key, + double default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_number()) { + return value.as_double(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const long double object::get(const std::string& key, + long double default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_number()) { + return value.as_long_double(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const std::string object::get(const std::string& key, + std::string default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_string()) { + return value.as_string(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE const std::string object::get(const std::string& key, + const char* default_value) const + { + if (exist(key)) { + value value = _object_data.at(key); + if (value.is_string()) { + return value.as_string(); + } + else { + return default_value; + } + } + else { + return default_value; + } + } + + MEOJSON_INLINE object::iterator object::begin() noexcept + { + return _object_data.begin(); + } + + MEOJSON_INLINE object::iterator object::end() noexcept + { + return _object_data.end(); + } + + MEOJSON_INLINE object::const_iterator object::begin() const noexcept + { + return _object_data.begin(); + } + + MEOJSON_INLINE object::const_iterator object::end() const noexcept + { + return _object_data.end(); + } + + MEOJSON_INLINE object::const_iterator object::cbegin() const noexcept + { + return _object_data.cbegin(); + } + + MEOJSON_INLINE object::const_iterator object::cend() const noexcept + { + return _object_data.cend(); + } + + MEOJSON_INLINE value& object::operator[](const std::string& key) + { + return _object_data[key]; + } + + MEOJSON_INLINE value& object::operator[](std::string&& key) + { + return _object_data[std::move(key)]; + } + + // const raw_object &object::raw_data() const + // { + // return _object_data; + // } + + MEOJSON_INLINE std::ostream& operator<<(std::ostream& out, const object& obj) + { + // TODO: format output + + out << obj.to_string(); + return out; + } + + template object::object(MapType map) + { + static_assert(std::is_constructible::value, + "Parameter can't be used to construct a " + "object::raw_object::value_type"); + for (auto&& ele : map) { + _object_data.emplace(std::move(ele)); + } + } + + // ************************* + // * value impl * + // ************************* + MEOJSON_INLINE value::value() = default; + + MEOJSON_INLINE value::value(const value& rhs) + : _type(rhs._type), _raw_data(rhs._raw_data), + _array_ptr(copy_unique_ptr(rhs._array_ptr)), + _object_ptr(copy_unique_ptr(rhs._object_ptr)) + { + ; + } + + MEOJSON_INLINE value::value(value&& rhs) noexcept = default; + + MEOJSON_INLINE value::value(bool b) + : _type(value_type::Boolean), _raw_data(b ? "true" : "false") + { + ; + } + + MEOJSON_INLINE value::value(int num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(unsigned num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(long num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(unsigned long num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(long long num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(unsigned long long num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(float num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(double num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(long double num) + : _type(value_type::Number), _raw_data(std::to_string(num)) + { + ; + } + + MEOJSON_INLINE value::value(const char* str) + : _type(value_type::String), _raw_data(unescape_string(str)) + { + ; + } + + MEOJSON_INLINE value::value(const std::string& str) + : _type(value_type::String), _raw_data(unescape_string(str)) + { + ; + } + + MEOJSON_INLINE value::value(std::string&& str) + : _type(value_type::String), _raw_data(unescape_string(std::move(str))) + { + ; + } + + MEOJSON_INLINE value::value(const array& arr) + : _type(value_type::Array), _raw_data(std::string()), + _array_ptr(std::make_unique(arr)) + { + ; + } + + MEOJSON_INLINE value::value(array&& arr) + : _type(value_type::Array), _raw_data(std::string()), + _array_ptr(std::make_unique(std::move(arr))) + { + ; + } + + MEOJSON_INLINE value::value(const object& obj) + : _type(value_type::Object), _raw_data(std::string()), + _object_ptr(std::make_unique(obj)) + { + ; + } + + MEOJSON_INLINE value::value(object&& obj) + : _type(value_type::Object), _raw_data(std::string()), + _object_ptr(std::make_unique(std::move(obj))) + { + ; + } + + // for Pimpl + MEOJSON_INLINE value::~value() = default; + + MEOJSON_INLINE bool value::exist(const std::string& key) const + { + return _type == value_type::Object && as_object().exist(key); + } + + MEOJSON_INLINE bool value::exist(size_t pos) const + { + return _type == value_type::Array && as_array().exist(pos); + } + + MEOJSON_INLINE const value& value::at(size_t pos) const + { + if (_type == value_type::Array && _array_ptr != nullptr) { + return _array_ptr->at(pos); + } + + throw exception("Wrong Type or data empty"); + } + + MEOJSON_INLINE const value& value::at(const std::string& key) const + { + if (_type == value_type::Object && _object_ptr != nullptr) { + return _object_ptr->at(key); + } + + throw exception("Wrong Type or data empty"); + } + + template + MEOJSON_INLINE auto value::get(const std::string& key, const Type& default_value) const + { + return is_object() ? as_object().get(key, default_value) : default_value; + } + + template + MEOJSON_INLINE auto value::get(size_t pos, const Type& default_value) const + { + return is_array() ? as_array().get(pos, default_value) : default_value; + } + + MEOJSON_INLINE const bool value::as_boolean() const + { + if (_type == value_type::Boolean) { + if (_raw_data == "true") { + return true; + } + else if (_raw_data == "false") { + return false; + } + else { + throw exception("Unknown Parse Error"); + } + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const int value::as_integer() const + { + if (_type == value_type::Number) { + return std::stoi(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + // const unsigned value::as_unsigned() const + // { + // if (_type == value_type::Number) + // { + // return std::stou(_raw_data); // not exist + // } + // else + // { + // throw exception("Wrong Type"); + // } + // } + + MEOJSON_INLINE const long value::as_long() const + { + if (_type == value_type::Number) { + return std::stol(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const unsigned long value::as_unsigned_long() const + { + if (_type == value_type::Number) { + return std::stoul(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const long long value::as_long_long() const + { + if (_type == value_type::Number) { + return std::stoll(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const unsigned long long value::as_unsigned_long_long() const + { + if (_type == value_type::Number) { + return std::stoull(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const float value::as_float() const + { + if (_type == value_type::Number) { + return std::stof(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const double value::as_double() const + { + if (_type == value_type::Number) { + return std::stod(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const long double value::as_long_double() const + { + if (_type == value_type::Number) { + return std::stold(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const std::string value::as_string() const + { + if (_type == value_type::String) { + return escape_string(_raw_data); + } + else { + throw exception("Wrong Type"); + } + } + + MEOJSON_INLINE const array& value::as_array() const + { + if (_type == value_type::Array && _array_ptr != nullptr) { + return *_array_ptr; + } + + throw exception("Wrong Type"); + } + + MEOJSON_INLINE const object& value::as_object() const + { + if (_type == value_type::Object && _object_ptr != nullptr) { + return *_object_ptr; + } + + throw exception("Wrong Type or data empty"); + } + + MEOJSON_INLINE array& value::as_array() + { + if (_type == value_type::Array && _array_ptr != nullptr) { + return *_array_ptr; + } + + throw exception("Wrong Type"); + } + + MEOJSON_INLINE object& value::as_object() + { + if (_type == value_type::Object && _object_ptr != nullptr) { + return *_object_ptr; + } + + throw exception("Wrong Type or data empty"); + } + + MEOJSON_INLINE const std::string value::to_string() const + { + switch (_type) { + case value_type::Null: + case value_type::Boolean: + case value_type::Number: + return _raw_data; + case value_type::String: + return '"' + _raw_data + '"'; + case value_type::Object: + return _object_ptr->to_string(); + case value_type::Array: + return _array_ptr->to_string(); + default: + throw exception("Unknown Value Type"); + } + } + + MEOJSON_INLINE const std::string value::format(std::string shift_str, + size_t basic_shift_count) const + { + switch (_type) { + case value_type::Null: + case value_type::Boolean: + case value_type::Number: + return _raw_data; + case value_type::String: + return '"' + _raw_data + '"'; + case value_type::Object: + return _object_ptr->format(shift_str, basic_shift_count); + case value_type::Array: + return _array_ptr->format(shift_str, basic_shift_count); + default: + throw exception("Unknown Value Type"); + } + } + + MEOJSON_INLINE value& value::operator=(const value& rhs) + { + _type = rhs._type; + _raw_data = rhs._raw_data; + _array_ptr = copy_unique_ptr(rhs._array_ptr); + _object_ptr = copy_unique_ptr(rhs._object_ptr); + + return *this; + } + + MEOJSON_INLINE value& value::operator=(value&& rhs) noexcept = default; + + MEOJSON_INLINE const value& value::operator[](size_t pos) const + { + if (_type == value_type::Array && _array_ptr != nullptr) { + return _array_ptr->operator[](pos); + } + // Array not support to create by operator[] + + throw exception("Wrong Type"); + } + + MEOJSON_INLINE value& value::operator[](size_t pos) + { + if (_type == value_type::Array && _array_ptr != nullptr) { + return _array_ptr->operator[](pos); + } + // Array not support to create by operator[] + + throw exception("Wrong Type"); + } + + MEOJSON_INLINE value& value::operator[](const std::string& key) + { + if (_type == value_type::Object && _object_ptr != nullptr) { + return _object_ptr->operator[](key); + } + // Create a new value by operator[] + else if (_type == value_type::Null) { + _type = value_type::Object; + _object_ptr = std::make_unique(); + return _object_ptr->operator[](key); + } + + throw exception("Wrong Type"); + } + + MEOJSON_INLINE value& value::operator[](std::string&& key) + { + if (_type == value_type::Object && _object_ptr != nullptr) { + return _object_ptr->operator[](std::move(key)); + } + // Create a new value by operator[] + else if (_type == value_type::Null) { + _type = value_type::Object; + _object_ptr = std::make_unique(); + return _object_ptr->operator[](std::move(key)); + } + + throw exception("Wrong Type"); + } + + MEOJSON_INLINE const value invalid_value() + { + return value(value_type::Invalid, std::string()); + } + + MEOJSON_INLINE std::ostream& operator<<(std::ostream& out, const value& val) + { + // TODO: format output + + out << val.to_string(); + return out; + } + + template + value::value(value_type type, Args &&...args) + : _type(type), _raw_data(std::forward(args)...) + { + static_assert(std::is_constructible::value, + "Parameter can't be used to construct a std::string"); + } + + // std::istream &operator>>(std::istream &in, value &val) + // { + // return in; + // } + + // ************************* + // * parser declare * + // ************************* + class parser + { + public: + ~parser() noexcept = default; + + static std::optional parse(const std::string& content); + + private: + parser(const std::string::const_iterator& cbegin, + const std::string::const_iterator& cend) noexcept + : _cur(cbegin), _end(cend) + {} + + std::optional parse(); + value parse_value(); + + value parse_null(); + value parse_boolean(); + value parse_number(); + // parse and return a value whose type is value_type::String + value parse_string(); + value parse_array(); + value parse_object(); + + // parse and return a std::string + std::optional parse_stdstring(); + + bool skip_whitespace() noexcept; + bool skip_digit(); + + private: + std::string::const_iterator _cur; + std::string::const_iterator _end; + }; + + std::optional parse(const std::string& content); + + // ************************* + // * parser impl * + // ************************* + MEOJSON_INLINE std::optional parser::parse(const std::string& content) + { + return parser(content.cbegin(), content.cend()).parse(); + } + + MEOJSON_INLINE std::optional parser::parse() + { + if (!skip_whitespace()) { + return std::nullopt; + } + + value result_value; + switch (*_cur) { + case '[': + result_value = parse_array(); + break; + case '{': + result_value = parse_object(); + break; + default: // A JSON payload should be an object or array + return std::nullopt; + } + + if (!result_value.valid()) { + return std::nullopt; + } + + // After the parsing is complete, there should be no more content other than + // spaces behind + if (skip_whitespace()) { + return std::nullopt; + } + + return result_value; + } + + MEOJSON_INLINE value parser::parse_value() + { + switch (*_cur) { + case 'n': + return parse_null(); + case 't': + case 'f': + return parse_boolean(); + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + return parse_number(); + case '"': + return parse_string(); + case '[': + return parse_array(); + case '{': + return parse_object(); + default: + return invalid_value(); + } + } + + MEOJSON_INLINE value parser::parse_null() + { + static const std::string null_string = "null"; + + for (const char& ch : null_string) { + if (*_cur == ch) { + ++_cur; + } + else { + return invalid_value(); + } + } + + return value(); + } + + MEOJSON_INLINE value parser::parse_boolean() + { + static const std::string true_string = "true"; + static const std::string false_string = "false"; + + switch (*_cur) { + case 't': + for (const char& ch : true_string) { + if (*_cur == ch) { + ++_cur; + } + else { + return invalid_value(); + } + } + return true; + case 'f': + for (const char& ch : false_string) { + if (*_cur == ch) { + ++_cur; + } + else { + return invalid_value(); + } + } + return false; + default: + return invalid_value(); + } + } + + MEOJSON_INLINE value parser::parse_number() + { + const auto first = _cur; + if (*_cur == '-') { + ++_cur; + } + + // Numbers cannot have leading zeroes + if (_cur != _end && *_cur == '0' && _cur + 1 != _end && + std::isdigit(*(_cur + 1))) { + return invalid_value(); + } + + if (!skip_digit()) { + return invalid_value(); + } + + if (*_cur == '.') { + ++_cur; + if (!skip_digit()) { + return invalid_value(); + } + } + + if (*_cur == 'e' || *_cur == 'E') { + if (++_cur == _end) { + return invalid_value(); + } + if (*_cur == '+' || *_cur == '-') { + ++_cur; + } + if (!skip_digit()) { + return invalid_value(); + } + } + + return value(value_type::Number, first, _cur); + } + + MEOJSON_INLINE value parser::parse_string() + { + auto string_opt = parse_stdstring(); + if (!string_opt) { + return invalid_value(); + } + return value(value_type::String, std::move(string_opt).value()); + } + + MEOJSON_INLINE value parser::parse_array() + { + if (*_cur == '[') { + ++_cur; + } + else { + return invalid_value(); + } + + if (!skip_whitespace()) { + return invalid_value(); + } + else if (*_cur == ']') { + ++_cur; + // empty array + return array(); + } + + array result; + while (true) { + if (!skip_whitespace()) { + return invalid_value(); + } + + value val = parse_value(); + + if (!val.valid() || !skip_whitespace()) { + return invalid_value(); + } + + result.emplace_back(std::move(val)); + + if (*_cur == ',') { + ++_cur; + } + else { + break; + } + } + + if (skip_whitespace() && *_cur == ']') { + ++_cur; + } + else { + return invalid_value(); + } + + return result; + } + + MEOJSON_INLINE value parser::parse_object() + { + if (*_cur == '{') { + ++_cur; + } + else { + return invalid_value(); + } + + if (!skip_whitespace()) { + return invalid_value(); + } + else if (*_cur == '}') { + ++_cur; + // empty object + return object(); + } + + object result; + while (true) { + if (!skip_whitespace()) { + return invalid_value(); + } + + auto key_opt = parse_stdstring(); + + if (key_opt && skip_whitespace() && *_cur == ':') { + ++_cur; + } + else { + return invalid_value(); + } + + if (!skip_whitespace()) { + return invalid_value(); + } + + value val = parse_value(); + + if (!val.valid() || !skip_whitespace()) { + return invalid_value(); + } + + std::string key_escape = escape_string(std::move(key_opt).value()); + result.emplace(std::move(key_escape), std::move(val)); + + if (*_cur == ',') { + ++_cur; + } + else { + break; + } + } + + if (skip_whitespace() && *_cur == '}') { + ++_cur; + } + else { + return invalid_value(); + } + + return result; + } + + MEOJSON_INLINE std::optional parser::parse_stdstring() + { + if (*_cur == '"') { + ++_cur; + } + else { + return std::nullopt; + } + + const auto first = _cur; + auto last = _cur; + bool is_string_end = false; + while (!is_string_end && _cur != _end) { + switch (*_cur) { + case '\t': + case '\r': + case '\n': + return std::nullopt; + case '\\': { + if (++_cur == _end) { + return std::nullopt; + } + switch (*_cur) { + case '"': + case '\\': + case '/': + case 'b': + case 'f': + case 'n': + case 'r': + case 't': + case 'u': + ++_cur; + break; + default: + // Illegal backslash escape + return std::nullopt; + } + break; + } + case '"': { + last = _cur; + ++_cur; + is_string_end = true; + break; + } + default: + ++_cur; + break; + } + } + if (_cur == _end) { + return std::nullopt; + } + + return std::string(first, last); + } + + MEOJSON_INLINE bool parser::skip_whitespace() noexcept + { + while (_cur != _end) { + switch (*_cur) { + case ' ': + case '\t': + case '\r': + case '\n': + ++_cur; + break; + default: + return true; + } + } + return false; + } + + MEOJSON_INLINE bool parser::skip_digit() + { + // At least one digit + if (_cur != _end && std::isdigit(*_cur)) { + ++_cur; + } + else { + return false; + } + + while (_cur != _end && std::isdigit(*_cur)) { + ++_cur; + } + + if (_cur != _end) { + return true; + } + else { + return false; + } + } + + MEOJSON_INLINE std::optional parse(const std::string& content) + { + return parser::parse(content); + } +} // namespace json diff --git a/3rdparty/include/meojson/json_array.h b/3rdparty/include/meojson/json_array.h deleted file mode 100644 index 4864f8a6a3..0000000000 --- a/3rdparty/include/meojson/json_array.h +++ /dev/null @@ -1,97 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace json -{ - class value; - - class array - { - public: - using raw_array = std::vector; - using iterator = raw_array::iterator; - using const_iterator = raw_array::const_iterator; - using reverse_iterator = raw_array::reverse_iterator; - using const_reverse_iterator = raw_array::const_reverse_iterator; - - array() = default; - array(const array& rhs) = default; - array(array&& rhs) noexcept = default; - array(const raw_array& arr); - array(raw_array&& arr) noexcept; - array(std::initializer_list init_list); - template - array(ArrayType arr) { - static_assert( - std::is_constructible::value, - "Parameter can't be used to construct a json::value"); - for (auto&& ele : arr) { - _array_data.emplace_back(std::move(ele)); - } - } - - ~array() noexcept = default; - - bool empty() const noexcept { return _array_data.empty(); } - size_t size() const noexcept { return _array_data.size(); } - bool exist(size_t pos) const { return _array_data.size() < pos; } - const value& at(size_t pos) const; - const std::string to_string() const; - const std::string format(std::string shift_str = " ", size_t basic_shift_count = 0) const; - - const bool get(size_t pos, bool default_value) const; - const int get(size_t pos, int default_value) const; - const long get(size_t pos, long default_value) const; - const unsigned long get(size_t pos, unsigned default_value) const; - const long long get(size_t pos, long long default_value) const; - const unsigned long long get(size_t pos, unsigned long long default_value) const; - const float get(size_t pos, float default_value) const; - const double get(size_t pos, double default_value) const; - const long double get(size_t pos, long double default_value) const; - const std::string get(size_t pos, std::string default_value) const; - const std::string get(size_t pos, const char* default_value) const; - - template - decltype(auto) emplace_back(Args &&... args) - { - static_assert( - std::is_constructible::value, - "Parameter can't be used to construct a raw_array::value_type"); - return _array_data.emplace_back(std::forward(args)...); - } - - void clear() noexcept; - // void earse(size_t pos); - - iterator begin() noexcept; - iterator end() noexcept; - const_iterator begin() const noexcept; - const_iterator end() const noexcept; - const_iterator cbegin() const noexcept; - const_iterator cend() const noexcept; - - reverse_iterator rbegin() noexcept; - reverse_iterator rend() noexcept; - const_reverse_iterator rbegin() const noexcept; - const_reverse_iterator rend() const noexcept; - const_reverse_iterator crbegin() const noexcept; - const_reverse_iterator crend() const noexcept; - - const value& operator[](size_t pos) const; - value& operator[](size_t pos); - - array& operator=(const array&) = default; - array& operator=(array&&) noexcept = default; - - // const raw_array &raw_data() const; - - private: - raw_array _array_data; - }; - - std::ostream& operator<<(std::ostream& out, const array& arr); - -} // namespace json \ No newline at end of file diff --git a/3rdparty/include/meojson/json_aux.h b/3rdparty/include/meojson/json_aux.h deleted file mode 100644 index ebae472459..0000000000 --- a/3rdparty/include/meojson/json_aux.h +++ /dev/null @@ -1,97 +0,0 @@ -#pragma once - -#include -#include "json_value.h" - -namespace json -{ - static std::string unescape_string(std::string&& str) - { - std::string replace_str; - std::string escape_str = std::move(str); - - for (size_t pos = 0; pos < escape_str.size(); ++pos) - { - switch (escape_str[pos]) { - case '\"': - replace_str = R"(\")"; - break; - case '\\': - replace_str = R"(\\)"; - break; - case '\b': - replace_str = R"(\b)"; - break; - case '\f': - replace_str = R"(\f)"; - break; - case '\n': - replace_str = R"(\n)"; - break; - case '\r': - replace_str = R"(\r)"; - break; - case '\t': - replace_str = R"(\t)"; - break; - default: - continue; - break; - } - escape_str.replace(pos, 1, replace_str); - ++pos; - } - return escape_str; - } - - static std::string unescape_string(const std::string& str) - { - return unescape_string(std::string(str)); - } - - static std::string escape_string(std::string&& str) - { - std::string escape_str = std::move(str); - - for (size_t pos = 0; pos + 1 < escape_str.size(); ++pos) - { - if (escape_str[pos] != '\\') { - continue; - } - std::string replace_str; - switch (escape_str[pos + 1]) { - case '"': - replace_str = "\""; - break; - case '\\': - replace_str = "\\"; - break; - case 'b': - replace_str = "\b"; - break; - case 'f': - replace_str = "\f"; - break; - case 'n': - replace_str = "\n"; - break; - case 'r': - replace_str = "\r"; - break; - case 't': - replace_str = "\t"; - break; - default: - return std::string(); - break; - } - escape_str.replace(pos, 2, replace_str); - } - return escape_str; - } - - static std::string escape_string(const std::string& str) - { - return escape_string(std::string(str)); - } -} \ No newline at end of file diff --git a/3rdparty/include/meojson/json_exception.h b/3rdparty/include/meojson/json_exception.h deleted file mode 100644 index 474752248b..0000000000 --- a/3rdparty/include/meojson/json_exception.h +++ /dev/null @@ -1,27 +0,0 @@ -#pragma once - -#include -#include - -namespace json -{ - class exception : public std::exception - { - public: - exception() = default; - exception(const std::string& msg); - - exception(const exception&) = default; - exception& operator=(const exception&) = default; - exception(exception&&) = default; - exception& operator=(exception&&) = default; - - virtual ~exception() noexcept override = default; - - virtual const char* what() const noexcept override; - - private: - std::string m_msg; - }; - -} // namespace json \ No newline at end of file diff --git a/3rdparty/include/meojson/json_object.h b/3rdparty/include/meojson/json_object.h deleted file mode 100644 index ae3d414a97..0000000000 --- a/3rdparty/include/meojson/json_object.h +++ /dev/null @@ -1,88 +0,0 @@ -#pragma once - -#include -#include -#include - -#include "json_value.h" - -namespace json -{ - class object - { - public: - using raw_object = std::unordered_map; - using iterator = raw_object::iterator; - using const_iterator = raw_object::const_iterator; - - object() = default; - object(const object& rhs) = default; - object(object&& rhs) = default; - object(const raw_object& raw_obj); - object(raw_object&& raw_obj); - object(std::initializer_list init_list); - template - object(MapType map) { - static_assert( - std::is_constructible::value, - "Parameter can't be used to construct a json::object::raw_object::value_type"); - for (auto&& ele : map) { - _object_data.emplace(std::move(ele)); - } - } - - ~object() = default; - - bool empty() const noexcept { return _object_data.empty(); } - size_t size() const noexcept { return _object_data.size(); } - bool exist(const std::string& key) const { return _object_data.find(key) != _object_data.cend(); } - const value& at(const std::string& key) const; - const std::string to_string() const; - const std::string format(std::string shift_str = " ", size_t basic_shift_count = 0) const; - - const bool get(const std::string& key, bool default_value) const; - const int get(const std::string& key, int default_value) const; - const long get(const std::string& key, long default_value) const; - const unsigned long get(const std::string& key, unsigned default_value) const; - const long long get(const std::string& key, long long default_value) const; - const unsigned long long get(const std::string& key, unsigned long long default_value) const; - const float get(const std::string& key, float default_value) const; - const double get(const std::string& key, double default_value) const; - const long double get(const std::string& key, long double default_value) const; - const std::string get(const std::string& key, std::string default_value) const; - const std::string get(const std::string& key, const char* default_value) const; - - template - decltype(auto) emplace(Args &&... args) - { - static_assert( - std::is_constructible::value, - "Parameter can't be used to construct a raw_object::value_type"); - return _object_data.emplace(std::forward(args)...); - } - - void clear() noexcept; - bool earse(const std::string& key); - - iterator begin() noexcept; - iterator end() noexcept; - const_iterator begin() const noexcept; - const_iterator end() const noexcept; - const_iterator cbegin() const noexcept; - const_iterator cend() const noexcept; - - value& operator[](const std::string& key); - value& operator[](std::string&& key); - - object& operator=(const object&) = default; - object& operator=(object&&) = default; - - // const raw_object &raw_data() const; - - private: - raw_object _object_data; - }; - - std::ostream& operator<<(std::ostream& out, const json::object& obj); - -} // namespace json \ No newline at end of file diff --git a/3rdparty/include/meojson/json_parser.h b/3rdparty/include/meojson/json_parser.h deleted file mode 100644 index cb1a68f0eb..0000000000 --- a/3rdparty/include/meojson/json_parser.h +++ /dev/null @@ -1,50 +0,0 @@ -#pragma once - -#include -#include - -namespace json -{ - class value; - class object; - class array; - enum class value_type : char; - - class parser - { - public: - ~parser() noexcept = default; - - static std::optional parse(const std::string& content); - - private: - parser( - const std::string::const_iterator& cbegin, - const std::string::const_iterator& cend) noexcept - : _cur(cbegin), _end(cend) {} - - std::optional parse(); - value parse_value(); - - value parse_null(); - value parse_boolean(); - value parse_number(); - // parse and return a json::value whose type is value_type::String - value parse_string(); - value parse_array(); - value parse_object(); - - // parse and return a std::string - std::optional parse_stdstring(); - - bool skip_whitespace() noexcept; - bool skip_digit() noexcept; - - private: - std::string::const_iterator _cur; - std::string::const_iterator _end; - }; - - std::optional parse(const std::string& content); - -} // namespace json \ No newline at end of file diff --git a/3rdparty/include/meojson/json_value.h b/3rdparty/include/meojson/json_value.h deleted file mode 100644 index 37742894c8..0000000000 --- a/3rdparty/include/meojson/json_value.h +++ /dev/null @@ -1,160 +0,0 @@ -#pragma once - -#include -#include -// #include -#include - -namespace json -{ - enum class value_type : char - { - Invalid, - Null, - Boolean, - String, - Number, - Array, - Object, - NUM_T - }; - - class array; - class object; - - class value - { - using unique_array = std::unique_ptr; - using unique_object = std::unique_ptr; - - public: - value(); - value(const value& rhs); - value(value&& rhs) noexcept; - - value(bool b); - - value(int num); - value(unsigned num); - value(long num); - value(unsigned long num); - value(long long num); - value(unsigned long long num); - value(float num); - value(double num); - value(long double num); - - value(const char* str); - value(const std::string& str); - value(std::string&& str); - - value(const array& arr); - value(array&& arr); - // value(std::initializer_list init_list); // for array - - value(const object& obj); - value(object&& obj); - // error: conversion from ‘’ to ‘json::value’ is ambiguous - // value(std::initializer_list> init_list); // for object - - // Constructed from raw data - template - value(value_type type, Args &&...args) - : _type(type), - _raw_data(std::forward(args)...) - { - static_assert( - std::is_constructible::value, - "Parameter can't be used to construct a std::string"); - } - - // Prohibit conversion of other types to value - template - value(T) = delete; - - ~value(); - - bool valid() const noexcept { return _type != value_type::Invalid ? true : false; } - bool empty() const noexcept { return (_type == value_type::Null && _raw_data.compare("null") == 0) ? true : false; } - bool is_null() const noexcept { return empty(); } - bool is_number() const noexcept { return _type == value_type::Number; } - bool is_boolean() const noexcept { return _type == value_type::Boolean; } - bool is_string() const noexcept { return _type == value_type::String; } - bool is_array() const noexcept { return _type == value_type::Array; } - bool is_object() const noexcept { return _type == value_type::Object; } - bool exist(const std::string& key) const; - bool exist(size_t pos) const; - value_type type() const noexcept { return _type; } - const value& at(size_t pos) const; - const value& at(const std::string& key) const; - - template - decltype(auto) get(const std::string& key, Type default_value) const - { - return is_object() ? as_object().get(key, default_value) : default_value; - } - template - decltype(auto) get(size_t pos, Type default_value) const - { - return is_array() ? as_array().get(pos, default_value) : default_value; - } - - const bool as_boolean() const; - const int as_integer() const; - // const unsigned as_unsigned() const; - const long as_long() const; - const unsigned long as_unsigned_long() const; - const long long as_long_long() const; - const unsigned long long as_unsigned_long_long() const; - const float as_float() const; - const double as_double() const; - const long double as_long_double() const; - const std::string as_string() const; - const array& as_array() const; - const object& as_object() const; - - array& as_array(); - object& as_object(); - - // return raw string - const std::string to_string() const; - const std::string format(std::string shift_str = " ", size_t basic_shift_count = 0) const; - - value& operator=(const value& rhs); - value& operator=(value&&) noexcept; - - const value& operator[](size_t pos) const; - value& operator[](size_t pos); - value& operator[](const std::string& key); - value& operator[](std::string&& key); - //explicit operator bool() const noexcept { return valid(); } - - explicit operator bool() const { return as_boolean(); } - explicit operator int() const { return as_integer(); } - explicit operator long() const { return as_long(); } - explicit operator unsigned long() const { return as_unsigned_long(); } - explicit operator long long() const { return as_long_long(); } - explicit operator unsigned long long() const { return as_unsigned_long_long(); } - explicit operator float() const { return as_float(); } - explicit operator double() const { return as_double(); } - explicit operator long double() const { return as_long_double(); } - explicit operator std::string() const { return as_string(); } - - private: - template - static std::unique_ptr copy_unique_ptr(const std::unique_ptr& t) - { - return t == nullptr ? nullptr : std::make_unique(*t); - } - - value_type _type = value_type::Null; - std::string _raw_data = "null"; // If the value_type is Object or Array, the _raw_data will be a empty string. - unique_array _array_ptr; - unique_object _object_ptr; - }; - - const value invalid_value(); - std::ostream& operator<<(std::ostream& out, const value& val); - // std::istream &operator>>(std::istream &in, value &val); - -} // namespace json \ No newline at end of file diff --git a/3rdparty/lib/meojson.lib b/3rdparty/lib/meojson.lib deleted file mode 100644 index aaf52f9162..0000000000 Binary files a/3rdparty/lib/meojson.lib and /dev/null differ diff --git a/CMakeLists.txt b/CMakeLists.txt index 39bc4209b1..99248b9d0c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,7 +23,6 @@ add_library(MeoAssistant SHARED ${SRC}) find_library(PaddleOCR_LIB NAMES ppocr PATHS 3rdparty/lib) find_library(Penguin_LIB NAMES penguin-stats-recognize PATHS 3rdparty/lib) -find_library(MeoJson_LIB NAMES meojson PATHS 3rdparty/lib) if (WIN32) find_library(OpenCV NAMES opencv_world453 PATHS 3rdparty/lib) @@ -33,7 +32,7 @@ else () find_package(ZLIB REQUIRED) endif () -target_link_libraries(MeoAssistant ${OpenCV} ${PaddleOCR_LIB} ${Penguin_LIB} ${MeoJson_LIB} ${ZLIB}) +target_link_libraries(MeoAssistant ${OpenCV} ${PaddleOCR_LIB} ${Penguin_LIB} ${ZLIB}) if (BUILD_TEST) add_executable(test tools/TestCaller/main.cpp) diff --git a/docs/Linux编译教程.md b/docs/Linux编译教程.md index 0df085a375..3a81d76218 100644 --- a/docs/Linux编译教程.md +++ b/docs/Linux编译教程.md @@ -27,14 +27,6 @@ cmake ../ -DPADDLE_LIB=/your_path/paddle_inference/ -DOpenCV_DIR=/your_path_to_o # 若设备不支持 MKL, 可再额外添加 -DWITH_MKL=OFF 选项，并下载对应的 PaddlePaddle 预测库版本 ``` -### meojson - -https://github.com/MistEO/meojson - -```bash -make shared -``` - ### penguin-stats-recognize-v3 使用我魔改了接口的版本：https://github.com/MistEO/penguin-stats-recognize-v3 diff --git a/src/MeoAssistant/AbstractConfiger.cpp b/src/MeoAssistant/AbstractConfiger.cpp index a68c181bc8..fa97794d60 100644 --- a/src/MeoAssistant/AbstractConfiger.cpp +++ b/src/MeoAssistant/AbstractConfiger.cpp @@ -1,6 +1,6 @@ #include "AbstractConfiger.h" -#include +#include #include "AsstUtils.hpp" @@ -24,4 +24,4 @@ bool asst::AbstractConfiger::load(const std::string& filename) return false; } return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/AbstractTask.h b/src/MeoAssistant/AbstractTask.h index 6ce9bc834b..326044c713 100644 --- a/src/MeoAssistant/AbstractTask.h +++ b/src/MeoAssistant/AbstractTask.h @@ -3,7 +3,7 @@ #include #include #include -#include +#include #include "AsstMsg.h" diff --git a/src/MeoAssistant/AipOcr.cpp b/src/MeoAssistant/AipOcr.cpp index 229e9328c2..0f4c252e45 100644 --- a/src/MeoAssistant/AipOcr.cpp +++ b/src/MeoAssistant/AipOcr.cpp @@ -3,7 +3,7 @@ #include #include -#include +#include #include #include "AsstUtils.hpp" @@ -149,4 +149,4 @@ bool asst::AipOcr::parse_response(const json::value& json, std::vector out_result = result; return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/Assistant.cpp b/src/MeoAssistant/Assistant.cpp index d895cde581..6a9495c3a1 100644 --- a/src/MeoAssistant/Assistant.cpp +++ b/src/MeoAssistant/Assistant.cpp @@ -3,7 +3,7 @@ #include #include -#include +#include #include #include "AsstUtils.hpp" @@ -622,4 +622,4 @@ void Assistant::clear_cache() { Status.clear(); //Task.clear_cache(); -} +} \ No newline at end of file diff --git a/src/MeoAssistant/AsstCaller.cpp b/src/MeoAssistant/AsstCaller.cpp index 37d6a8706c..ac62296a2a 100644 --- a/src/MeoAssistant/AsstCaller.cpp +++ b/src/MeoAssistant/AsstCaller.cpp @@ -3,7 +3,7 @@ #include #include -#include +#include #include "Assistant.h" #include "AsstDef.h" @@ -248,9 +248,9 @@ bool AsstSetPenguinId(asst::Assistant* p_asst, const char* id) p_asst->set_penguin_id(id); return true; -} - -size_t ASSTAPI AsstGetImage(asst::Assistant* p_asst, void* buff, size_t buff_size) +} + +size_t ASSTAPI AsstGetImage(asst::Assistant* p_asst, void* buff, size_t buff_size) { if (p_asst == nullptr || buff == nullptr) { return 0; @@ -261,15 +261,15 @@ size_t ASSTAPI AsstGetImage(asst::Assistant* p_asst, void* buff, size_t buff_siz return 0; } memcpy(buff, img_data.data(), data_size); - return data_size; -} - -bool ASSTAPI AsstCtrlerClick(asst::Assistant* p_asst, int x, int y, bool block) + return data_size; +} + +bool ASSTAPI AsstCtrlerClick(asst::Assistant* p_asst, int x, int y, bool block) { if (p_asst == nullptr) { return false; } - return p_asst->ctrler_click(x, y, block); + return p_asst->ctrler_click(x, y, block); } //bool AsstSetParam(asst::Assistant* p_asst, const char* type, const char* param, const char* value) diff --git a/src/MeoAssistant/AsstMsg.h b/src/MeoAssistant/AsstMsg.h index 0b086324b8..a6875d08b3 100644 --- a/src/MeoAssistant/AsstMsg.h +++ b/src/MeoAssistant/AsstMsg.h @@ -4,7 +4,7 @@ #include #include -#include +#include namespace asst { diff --git a/src/MeoAssistant/GeneralConfiger.cpp b/src/MeoAssistant/GeneralConfiger.cpp index 9803aa0e26..22395aa589 100644 --- a/src/MeoAssistant/GeneralConfiger.cpp +++ b/src/MeoAssistant/GeneralConfiger.cpp @@ -1,6 +1,6 @@ #include "GeneralConfiger.h" -#include +#include bool asst::GeneralConfiger::parse(const json::value& json) { @@ -60,4 +60,4 @@ bool asst::GeneralConfiger::parse(const json::value& json) } return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/InfrastConfiger.cpp b/src/MeoAssistant/InfrastConfiger.cpp index 14816b9d04..22876404a9 100644 --- a/src/MeoAssistant/InfrastConfiger.cpp +++ b/src/MeoAssistant/InfrastConfiger.cpp @@ -1,6 +1,6 @@ #include "InfrastConfiger.h" -#include +#include bool asst::InfrastConfiger::parse(const json::value& json) { @@ -209,4 +209,4 @@ bool asst::InfrastConfiger::parse(const json::value& json) m_facilities_info.emplace(facility_name, std::move(fac_info)); } return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/ItemConfiger.cpp b/src/MeoAssistant/ItemConfiger.cpp index 1a0e80cc87..32c8212a60 100644 --- a/src/MeoAssistant/ItemConfiger.cpp +++ b/src/MeoAssistant/ItemConfiger.cpp @@ -1,6 +1,6 @@ #include "ItemConfiger.h" -#include +#include bool asst::ItemConfiger::parse(const json::value& json) { @@ -9,4 +9,4 @@ bool asst::ItemConfiger::parse(const json::value& json) m_item_name.emplace(id, std::move(name)); } return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/MeoAssistant.vcxproj b/src/MeoAssistant/MeoAssistant.vcxproj index 0b52ba17a2..0e2c43b0f5 100644 --- a/src/MeoAssistant/MeoAssistant.vcxproj +++ b/src/MeoAssistant/MeoAssistant.vcxproj @@ -191,7 +191,7 @@ true true true - meojson.lib;ppocr.lib;opencv_world453.lib;penguin-stats-recognize.lib;zlibstatic.lib;%(AdditionalDependencies) + ppocr.lib;opencv_world453.lib;penguin-stats-recognize.lib;zlibstatic.lib;%(AdditionalDependencies) RequireAdministrator @@ -237,7 +237,7 @@ xcopy /e /y /i /c $(SolutionDir)3rdparty\resource $(TargetDir)resource true true true - meojson.lib;ppocr.lib;opencv_world453.lib;penguin-stats-recognize.lib;zlibstatic.lib;%(AdditionalDependencies) + ppocr.lib;opencv_world453.lib;penguin-stats-recognize.lib;zlibstatic.lib;%(AdditionalDependencies) RequireAdministrator diff --git a/src/MeoAssistant/PenguinPack.cpp b/src/MeoAssistant/PenguinPack.cpp index 5eb4fd66d5..c634b764f7 100644 --- a/src/MeoAssistant/PenguinPack.cpp +++ b/src/MeoAssistant/PenguinPack.cpp @@ -2,7 +2,7 @@ #include -#include +#include #include namespace penguin { @@ -87,4 +87,4 @@ bool asst::PenguinPack::load_templ(const std::string& item_id, const std::string penguin::load_templ_with_data(item_id.c_str(), image.rows, image.cols, image.type(), image.data); return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/ProcessTask.cpp b/src/MeoAssistant/ProcessTask.cpp index e446c3767c..a4002e0e5e 100644 --- a/src/MeoAssistant/ProcessTask.cpp +++ b/src/MeoAssistant/ProcessTask.cpp @@ -3,7 +3,7 @@ #include #include -#include +#include #include "AsstUtils.hpp" #include "Controller.h" @@ -231,4 +231,4 @@ void asst::ProcessTask::exec_swipe_task(ProcessTaskAction action) default: // 走不到这里，TODO 报个错 break; } -} +} \ No newline at end of file diff --git a/src/MeoAssistant/RecruitConfiger.cpp b/src/MeoAssistant/RecruitConfiger.cpp index 19a9a27e0b..9ff666b6c3 100644 --- a/src/MeoAssistant/RecruitConfiger.cpp +++ b/src/MeoAssistant/RecruitConfiger.cpp @@ -2,7 +2,7 @@ #include -#include +#include bool asst::RecruitConfiger::parse(const json::value& json) { @@ -34,4 +34,4 @@ bool asst::RecruitConfiger::parse(const json::value& json) }); return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/Resource.cpp b/src/MeoAssistant/Resource.cpp index 1e82390dbc..d0ebf85f97 100644 --- a/src/MeoAssistant/Resource.cpp +++ b/src/MeoAssistant/Resource.cpp @@ -4,7 +4,7 @@ #include #include -#include +#include #include "AsstDef.h" @@ -78,4 +78,4 @@ bool asst::Resource::load(const std::string& dir) } return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/StageDropsTaskPlugin.h b/src/MeoAssistant/StageDropsTaskPlugin.h index 7b55508c2b..a76d303257 100644 --- a/src/MeoAssistant/StageDropsTaskPlugin.h +++ b/src/MeoAssistant/StageDropsTaskPlugin.h @@ -4,7 +4,7 @@ #include #include -#include +#include namespace asst { diff --git a/src/MeoAssistant/TaskData.cpp b/src/MeoAssistant/TaskData.cpp index 1cfe036afd..ab0d4273eb 100644 --- a/src/MeoAssistant/TaskData.cpp +++ b/src/MeoAssistant/TaskData.cpp @@ -2,7 +2,7 @@ #include -#include +#include #include "AsstDef.h" #include "GeneralConfiger.h" diff --git a/src/MeoAssistant/UserConfiger.cpp b/src/MeoAssistant/UserConfiger.cpp index 3de507f872..ee9fda44d5 100644 --- a/src/MeoAssistant/UserConfiger.cpp +++ b/src/MeoAssistant/UserConfiger.cpp @@ -2,7 +2,7 @@ #include -#include +#include constexpr static const char* EmulatorPathKey = "emulatorPath"; @@ -45,4 +45,4 @@ bool asst::UserConfiger::save() ofs.close(); return true; -} +} \ No newline at end of file diff --git a/src/MeoAssistant/UserConfiger.h b/src/MeoAssistant/UserConfiger.h index 1bab48aac7..08364af540 100644 --- a/src/MeoAssistant/UserConfiger.h +++ b/src/MeoAssistant/UserConfiger.h @@ -2,7 +2,7 @@ #include "AbstractConfiger.h" -#include +#include #include namespace asst