chore: update meojson to v5.1.1

Author: MistEO

include/meojson/common/array.hpp

@@ -81,6 +81,7 @@ class array
             bool> = true>
     array(const arr_t<value_t, size>& arr)
     {
+        _array_data.reserve(size);
         for (size_t i = 0; i < size; i++) {
             _array_data.emplace_back(arr.at(i));
         }
@@ -97,6 +98,7 @@ class array
             bool> = true>
     array(arr_t<value_t, size>&& arr)
     {
+        _array_data.reserve(size);
         for (size_t i = 0; i < size; i++) {
             _array_data.emplace_back(std::move(arr.at(i)));
         }
@@ -111,6 +113,9 @@ class array
             bool> = true>
     array(const collection_t& coll)
     {
+        if constexpr (_utils::has_size<collection_t>::value) {
+            _array_data.reserve(coll.size());
+        }
         for (const auto& val : coll) {
             _array_data.emplace_back(val);
         }
@@ -124,6 +129,9 @@ class array
             bool> = true>
     array(collection_t&& coll)
     {
+        if constexpr (_utils::has_size<collection_t>::value) {
+            _array_data.reserve(coll.size());
+        }
         for (auto& val : coll) {
             _array_data.emplace_back(std::move(val));
         }
@@ -141,6 +149,7 @@ class array
     array(const tuple_t<args_t...>& tpl)
     {
         constexpr size_t tuple_size = std::tuple_size_v<tuple_t<args_t...>>;
+        _array_data.reserve(tuple_size);
         construct_from_tuple_helper(tpl, std::make_index_sequence<tuple_size>());
     }
 
@@ -155,6 +164,7 @@ class array
     array(tuple_t<args_t...>&& tpl)
     {
         constexpr size_t tuple_size = std::tuple_size_v<tuple_t<args_t...>>;
+        _array_data.reserve(tuple_size);
         construct_from_tuple_move_helper(std::move(tpl), std::make_index_sequence<tuple_size>());
     }
 
@@ -207,6 +217,9 @@ class array
     template <typename tuple_t, size_t... Is>
     void move_as_tuple_helper(tuple_t& result, std::index_sequence<Is...>);
 
+    void dump_to(std::string& out) const;
+    void format_to(std::string& out, size_t indent, size_t indent_times) const;
+
 public:
 
     // Usage: get(key_1, key_2, ..., default_value);
@@ -215,6 +228,7 @@ class array
 
     template <typename value_t = value>
     std::optional<value_t> find(size_t pos) const;
+    const value* find_value(size_t pos) const;
 
     template <typename... args_t>
     decltype(auto) emplace_back(args_t&&... args);

include/meojson/common/array_impl.hpp

@@ -4,6 +4,21 @@
 
 namespace json
 {
+namespace _array_impl_detail
+{
+inline void append_array(array::raw_array& dst, const array& src)
+{
+    dst.reserve(dst.size() + src.size());
+    dst.insert(dst.end(), src.begin(), src.end());
+}
+
+inline void append_array_move(array::raw_array& dst, array& src)
+{
+    dst.reserve(dst.size() + src.size());
+    dst.insert(dst.end(), std::make_move_iterator(src.begin()), std::make_move_iterator(src.end()));
+}
+} // namespace _array_impl_detail
+
 inline array::array() = default;
 inline array::array(const array& rhs) = default;
 inline array::array(array&& rhs) noexcept = default;
@@ -56,7 +71,11 @@ inline bool array::erase(size_t pos)
 
 inline bool array::erase(iterator iter)
 {
-    return _array_data.erase(iter) != _array_data.end();
+    if (iter == _array_data.end()) {
+        return false;
+    }
+    _array_data.erase(iter);
+    return true;
 }
 
 template <typename... args_t>
@@ -79,32 +98,44 @@ inline const value& array::at(size_t pos) const
 
 inline std::string array::to_string() const
 {
-    std::string str { '[' };
+    std::string str;
+    dump_to(str);
+    return str;
+}
+
+inline void array::dump_to(std::string& out) const
+{
+    out.push_back('[');
     for (auto iter = _array_data.cbegin(); iter != _array_data.cend();) {
-        str += iter->to_string();
+        iter->dump_to(out);
         if (++iter != _array_data.cend()) {
-            str += ',';
+            out.push_back(',');
         }
     }
-    str += ']';
-    return str;
+    out.push_back(']');
 }
 
 inline std::string array::format(size_t indent, size_t indent_times) const
 {
-    const std::string tail_indent(indent * indent_times, ' ');
-    const std::string body_indent(indent * (indent_times + 1), ' ');
+    std::string str;
+    format_to(str, indent, indent_times);
+    return str;
+}
 
-    std::string str { '[', '\n' };
+inline void array::format_to(std::string& out, size_t indent, size_t indent_times) const
+{
+    out.push_back('[');
+    out.push_back('\n');
     for (auto iter = _array_data.cbegin(); iter != _array_data.cend();) {
-        str += body_indent + iter->format(indent, indent_times + 1);
+        out.append(indent * (indent_times + 1), ' ');
+        iter->format_to(out, indent, indent_times + 1);
         if (++iter != _array_data.cend()) {
-            str += ',';
+            out.push_back(',');
         }
-        str += '\n';
+        out.push_back('\n');
     }
-    str += tail_indent + ']';
-    return str;
+    out.append(indent * indent_times, ' ');
+    out.push_back(']');
 }
 
 inline std::string array::dumps(std::optional<size_t> indent) const
@@ -144,63 +175,36 @@ inline auto array::get(std::tuple<key_then_default_value_t...> keys_then_default
 template <typename value_t, typename... rest_keys_t>
 inline auto array::get_helper(const value_t& default_value, size_t pos, rest_keys_t&&... rest) const
 {
-    constexpr bool is_json = std::is_same_v<value, value_t> || std::is_same_v<array, value_t> || std::is_same_v<object, value_t>;
-    constexpr bool is_string = std::is_constructible_v<std::string, value_t> && !is_json;
-
     if (!contains(pos)) {
-        if constexpr (is_string) {
-            return std::string(default_value);
-        }
-        else {
-            return value_t(default_value);
-        }
+        return _utils::default_or_string(default_value);
     }
 
-    return at(pos).get_helper(default_value, std::forward<rest_keys_t>(rest)...);
+    return _array_data[pos].get_helper(default_value, std::forward<rest_keys_t>(rest)...);
 }
 
 template <typename value_t>
 inline auto array::get_helper(const value_t& default_value, size_t pos) const
 {
-    constexpr bool is_json = std::is_same_v<value, value_t> || std::is_same_v<array, value_t> || std::is_same_v<object, value_t>;
-    constexpr bool is_string = std::is_constructible_v<std::string, value_t> && !is_json;
-
     if (!contains(pos)) {
-        if constexpr (is_string) {
-            return std::string(default_value);
-        }
-        else {
-            return value_t(default_value);
-        }
+        return _utils::default_or_string(default_value);
     }
 
-    auto val = _array_data[pos];
-    if (val.template is<value_t>()) {
-        if constexpr (is_string) {
-            return val.template as<std::string>();
-        }
-        else {
-            return val.template as<value_t>();
-        }
-    }
-    else {
-        if constexpr (is_string) {
-            return std::string(default_value);
-        }
-        else {
-            return value_t(default_value);
-        }
-    }
+    return _utils::json_value_or_default(_array_data[pos], default_value);
 }
 
 template <typename value_t>
 inline std::optional<value_t> array::find(size_t pos) const
 {
-    if (!contains(pos)) {
+    const auto* val = find_value(pos);
+    if (!val) {
         return std::nullopt;
     }
-    const auto& val = _array_data.at(pos);
-    return val.template is<value_t>() ? std::optional<value_t>(val.template as<value_t>()) : std::nullopt;
+    return val->template is<value_t>() ? std::optional<value_t>(val->template as<value_t>()) : std::nullopt;
+}
+
+inline const value* array::find_value(size_t pos) const
+{
+    return contains(pos) ? &_array_data[pos] : nullptr;
 }
 
 inline typename array::iterator array::begin() noexcept
@@ -276,38 +280,38 @@ inline const value& array::operator[](size_t pos) const
 inline array array::operator+(const array& rhs) const&
 {
     array temp = *this;
-    temp._array_data.insert(temp._array_data.end(), rhs.begin(), rhs.end());
+    _array_impl_detail::append_array(temp._array_data, rhs);
     return temp;
 }
 
 inline array array::operator+(array&& rhs) const&
 {
     array temp = *this;
-    temp._array_data.insert(temp._array_data.end(), std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()));
+    _array_impl_detail::append_array_move(temp._array_data, rhs);
     return temp;
 }
 
 inline array array::operator+(const array& rhs) &&
 {
-    _array_data.insert(_array_data.end(), rhs.begin(), rhs.end());
+    _array_impl_detail::append_array(_array_data, rhs);
     return std::move(*this);
 }
 
 inline array array::operator+(array&& rhs) &&
 {
-    _array_data.insert(_array_data.end(), std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()));
+    _array_impl_detail::append_array_move(_array_data, rhs);
     return std::move(*this);
 }
 
 inline array& array::operator+=(const array& rhs)
 {
-    _array_data.insert(_array_data.end(), rhs.begin(), rhs.end());
+    _array_impl_detail::append_array(_array_data, rhs);
     return *this;
 }
 
 inline array& array::operator+=(array&& rhs)
 {
-    _array_data.insert(_array_data.end(), std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()));
+    _array_impl_detail::append_array_move(_array_data, rhs);
     return *this;
 }
 
@@ -344,6 +348,9 @@ inline T array::as() const&
     }
     else if constexpr (_utils::is_collection<T>) {
         T result;
+        if constexpr (_utils::has_reserve<T>::value) {
+            result.reserve(_array_data.size());
+        }
         for (const auto& val : _array_data) {
             if constexpr (_utils::has_emplace_back<T>::value) {
                 result.emplace_back(val.as<typename T::value_type>());
@@ -387,6 +394,9 @@ inline T array::as() &&
     }
     else if constexpr (_utils::is_collection<T>) {
         T result;
+        if constexpr (_utils::has_reserve<T>::value) {
+            result.reserve(_array_data.size());
+        }
         for (auto& val : _array_data) {
             if constexpr (_utils::has_emplace_back<T>::value) {
                 result.emplace_back(std::move(val).as<typename T::value_type>());
@@ -427,4 +437,4 @@ inline void array::move_as_tuple_helper(tuple_t& result, std::index_sequence<Is.
     using std::get;
     ((get<Is>(result) = std::move(_array_data[Is]).template as<std::tuple_element_t<Is, tuple_t>>()), ...);
 }
-} // namespace json
+} // namespace json

include/meojson/common/object.hpp

@@ -130,6 +130,7 @@ class object
 
     template <typename value_t = value>
     std::optional<value_t> find(const std::string& key) const;
+    const value* find_value(const std::string& key) const;
 
     template <typename... args_t>
     decltype(auto) emplace(args_t&&... args);
@@ -236,6 +237,9 @@ class object
     template <typename value_t>
     auto get_helper(const value_t& default_value, const std::string& key) const;
 
+    void dump_to(std::string& out) const;
+    void format_to(std::string& out, size_t indent, size_t indent_times) const;
+
     std::string format(size_t indent, size_t indent_times) const;
 
 private: