pupbrained/draconisplusplus
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

weh

Browse source
This commit is contained in:
Mars 2024-06-09 18:55:00 -04:00
parent 05451841e8
commit 94d08a02d6
Signed by: pupbrained
GPG key ID: 874E22DF2F9DFCB5
60 changed files with 610 additions and 299 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.clang-format
View file

@ -6,7 +6,6 @@ AllowShortBlocksOnASingleLine: Always
AllowShortCompoundRequirementOnASingleLine: true
AllowShortEnumsOnASingleLine: true
AllowShortFunctionsOnASingleLine: true
AllowShortIfStatementsOnASingleLine: WithoutElse
AllowShortLoopsOnASingleLine: true
BasedOnStyle: Chromium
BinPackArguments: false

1
.clang-tidy
View file

@ -15,7 +15,6 @@ Checks: >
-llvm-include-order,
-llvmlibc-*,
-misc-non-private-member-variables-in-classes,
-modernize-use-trailing-return-type,
-readability-braces-around-statements,
-readability-implicit-bool-conversion,
-readability-isolate-declaration,

4
include/rfl/Box.hpp
View file

@ -25,7 +25,9 @@ namespace rfl {
/// You can generate them from unique_ptrs as well, in which case it will
/// return an Error, if the unique_ptr is not set.
static Result<Box<T>> make(std::unique_ptr<T>&& _ptr) {
if (!_ptr) { return Error("std::unique_ptr was a nullptr."); }
if (!_ptr) {
return Error("std::unique_ptr was a nullptr.");
}
return Box<T>(std::move(_ptr));
}

4
include/rfl/Literal.hpp
View file

@ -297,7 +297,9 @@ namespace rfl {
template <int _i = 0>
static Result<int> find_value(const std::string& _str) {
using FieldType = typename std::tuple_element<_i, FieldsType>::type;
if (FieldType::field_.str() == _str) { return _i; }
if (FieldType::field_.str() == _str) {
return _i;
}
if constexpr (_i + 1 == num_fields_) {
return Error(
"Literal does not support string '" + _str +

9
include/rfl/NamedTuple.hpp
View file

@ -487,13 +487,16 @@ namespace rfl {
if constexpr (size == _index) {
return make_replaced<_index, V, T>(
std::forward<V>(_values), std::forward<T>(_val),
std::forward<Args>(_args)..., FieldType(std::forward<T>(_val))
std::forward<V>(_values),
std::forward<T>(_val),
std::forward<Args>(_args)...,
FieldType(std::forward<T>(_val))
);
} else {
using U = typename FieldType::Type;
return make_replaced<_index, V, T>(
std::forward<V>(_values), std::forward<T>(_val),
std::forward<V>(_values),
std::forward<T>(_val),
std::forward<Args>(_args)...,
FieldType(std::forward<U>(std::get<size>(_values)))
);

4
include/rfl/OneOf.hpp
View file

@ -52,7 +52,9 @@ namespace rfl {
_r.or_else(push_back);
if constexpr (sizeof...(Tail) == 0) {
if (_errors.size() == sizeof...(Cs)) { return _value; }
if (_errors.size() == sizeof...(Cs)) {
return _value;
}
return make_error_message(_errors);
} else {
return validate_impl<T, Tail...>(

8
include/rfl/Ref.hpp
View file

@ -25,14 +25,18 @@ namespace rfl {
/// You can generate them from shared_ptrs as well, in which case it will
/// return an Error, if the shared_ptr is not set.
static Result<Ref<T>> make(std::shared_ptr<T>&& _ptr) {
if (!_ptr) { return Error("std::shared_ptr was a nullptr."); }
if (!_ptr) {
return Error("std::shared_ptr was a nullptr.");
}
return Ref<T>(std::move(_ptr));
}
/// You can generate them from shared_ptrs as well, in which case it will
/// return an Error, if the shared_ptr is not set.
static Result<Ref<T>> make(const std::shared_ptr<T>& _ptr) {
if (!_ptr) { return Error("std::shared_ptr was a nullptr."); }
if (!_ptr) {
return Error("std::shared_ptr was a nullptr.");
}
return Ref<T>(_ptr);
}

8
include/rfl/Result.hpp
View file

@ -188,7 +188,9 @@ namespace rfl {
/// Assigns the underlying object.
Result<T>& operator=(const Result<T>& _other) {
if (this == &_other) { return *this; }
if (this == &_other) {
return *this;
}
destroy();
success_ = _other.success_;
copy_from_other(_other);
@ -197,7 +199,9 @@ namespace rfl {
/// Assigns the underlying object.
Result<T>& operator=(Result<T>&& _other) noexcept {
if (this == &_other) { return *this; }
if (this == &_other) {
return *this;
}
destroy();
success_ = _other.success_;
move_from_other(_other);

4
include/rfl/Timestamp.hpp
View file

@ -78,7 +78,9 @@ namespace rfl {
std::istringstream input(_s);
input.imbue(std::locale(setlocale(LC_ALL, nullptr)));
input >> std::get_time(_tm, _f);
if (input.fail()) { return NULL; }
if (input.fail()) {
return NULL;
}
return (char*)(_s + input.tellg());
}
#endif

8
include/rfl/bson/Reader.hpp
View file

@ -60,7 +60,9 @@ namespace rfl {
if (bson_iter_init(&iter, &b)) {
while (bson_iter_next(&iter)) {
auto key = std::string(bson_iter_key(&iter));
if (key == _name) { return to_input_var(&iter); }
if (key == _name) {
return to_input_var(&iter);
}
}
}
}
@ -146,7 +148,9 @@ namespace rfl {
if (bson_iter_init(&iter, &b)) {
while (bson_iter_next(&iter)) {
const auto err = _array_reader.read(to_input_var(&iter));
if (err) { return err; }
if (err) {
return err;
}
}
}
}

19
include/rfl/bson/Writer.hpp
View file

@ -127,7 +127,9 @@ namespace rfl {
) const noexcept {
subdocs_->emplace_back(rfl::Box<BSONType>());
bson_append_document_begin(
_parent->val_, _name.data(), static_cast<int>(_name.size()),
_parent->val_,
_name.data(),
static_cast<int>(_name.size()),
&(subdocs_->back()->val_)
);
return OutputObjectType(
@ -169,8 +171,11 @@ namespace rfl {
) const noexcept {
if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
bson_append_utf8(
_parent->val_, _name.data(), static_cast<int>(_name.size()),
_var.c_str(), static_cast<int>(_var.size())
_parent->val_,
_name.data(),
static_cast<int>(_name.size()),
_var.c_str(),
static_cast<int>(_var.size())
);
} else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
bson_append_bool(
@ -178,12 +183,16 @@ namespace rfl {
);
} else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
bson_append_double(
_parent->val_, _name.data(), static_cast<int>(_name.size()),
_parent->val_,
_name.data(),
static_cast<int>(_name.size()),
static_cast<double>(_var)
);
} else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
bson_append_int64(
_parent->val_, _name.data(), static_cast<int>(_name.size()),
_parent->val_,
_name.data(),
static_cast<int>(_name.size()),
static_cast<std::int64_t>(_var)
);
} else if constexpr (std::is_same<std::remove_cvref_t<T>, bson_oid_t>(

68
include/rfl/cbor/Reader.hpp
View file

@ -52,21 +52,33 @@ namespace rfl {
CborValue val;
auto buffer = std::vector<char>();
auto err = cbor_value_enter_container(_obj.val_, &val);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
size_t length = 0;
err = cbor_value_get_map_length(_obj.val_, &length);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
for (size_t i = 0; i < length; ++i) {
if (!cbor_value_is_text_string(&val)) {
return Error("Expected the key to be a string value.");
}
err = get_string(&val, &buffer);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
err = cbor_value_advance(&val);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (_name == buffer.data()) { return to_input_var(&val); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
if (_name == buffer.data()) {
return to_input_var(&val);
}
err = cbor_value_advance(&val);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
}
return Error("No field named '" + _name + "' was found.");
}
@ -83,7 +95,9 @@ namespace rfl {
}
std::vector<char> buffer;
const auto err = get_string(_var.val_, &buffer);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
return std::string(buffer.data());
} else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
if (!cbor_value_is_boolean(_var.val_)) {
@ -91,24 +105,32 @@ namespace rfl {
}
bool result = false;
const auto err = cbor_value_get_boolean(_var.val_, &result);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
return result;
} else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>() ||
std::is_integral<std::remove_cvref_t<T>>()) {
if (cbor_value_is_integer(_var.val_)) {
std::int64_t result = 0;
const auto err = cbor_value_get_int64(_var.val_, &result);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
return static_cast<T>(result);
} else if (cbor_value_is_float(_var.val_)) {
float result = 0.0;
const auto err = cbor_value_get_float(_var.val_, &result);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
return static_cast<T>(result);
} else if (cbor_value_is_double(_var.val_)) {
double result = 0.0;
const auto err = cbor_value_get_double(_var.val_, &result);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
return static_cast<T>(result);
}
return rfl::Error(
@ -156,7 +178,9 @@ namespace rfl {
}
for (size_t i = 0; i < length; ++i) {
const auto err2 = _array_reader.read(to_input_var(&val));
if (err2) { return err2; }
if (err2) {
return err2;
}
err = cbor_value_advance(&val);
if (err != CborNoError && err != CborErrorOutOfMemory) {
return Error(cbor_error_string(err));
@ -172,19 +196,27 @@ namespace rfl {
) const noexcept {
size_t length = 0;
auto err = cbor_value_get_map_length(_obj.val_, &length);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
CborValue val;
err = cbor_value_enter_container(_obj.val_, &val);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
auto buffer = std::vector<char>();
for (size_t i = 0; i < length; ++i) {
err = get_string(&val, &buffer);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
err = cbor_value_advance(&val);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
if (err != CborNoError) {
return Error(cbor_error_string(err));
}
const auto name = std::string_view(buffer.data(), buffer.size() - 1);
_object_reader.read(name, InputVarType {&val});
cbor_value_advance(&val);
@ -206,7 +238,9 @@ namespace rfl {
const noexcept {
size_t length = 0;
auto err = cbor_value_get_string_length(_ptr, &length);
if (err != CborNoError && err != CborErrorOutOfMemory) { return err; }
if (err != CborNoError && err != CborErrorOutOfMemory) {
return err;
}
_buffer->resize(length + 1);
(*_buffer)[length] = '\0';
return cbor_value_copy_text_string(

6
include/rfl/cbor/write.hpp
View file

@ -23,8 +23,10 @@ namespace rfl {
using T = std::remove_cvref_t<decltype(_obj)>;
using ParentType = parsing::Parent<Writer>;
cbor_encoder_init(
_encoder, reinterpret_cast<uint8_t*>(_buffer->data()),
_buffer->size(), 0
_encoder,
reinterpret_cast<uint8_t*>(_buffer->data()),
_buffer->size(),
0
);
const auto writer = Writer(_encoder);
Parser<T, Processors<Ps...>>::write(

16
include/rfl/enums.hpp
View file

@ -29,8 +29,8 @@ namespace rfl {
// to their values.
template <internal::enums::is_scoped_enum EnumType>
auto get_enumerators() {
constexpr auto names = internal::enums::get_enum_names<
EnumType, internal::enums::is_flag_enum<EnumType>>();
constexpr auto names = internal::enums::
get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
return internal::enums::names_to_enumerator_named_tuple(names);
}
@ -38,8 +38,8 @@ namespace rfl {
// to their underlying values.
template <internal::enums::is_scoped_enum EnumType>
auto get_underlying_enumerators() {
constexpr auto names = internal::enums::get_enum_names<
EnumType, internal::enums::is_flag_enum<EnumType>>();
constexpr auto names = internal::enums::
get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
return internal::enums::names_to_underlying_enumerator_named_tuple(names);
}
@ -47,8 +47,8 @@ namespace rfl {
// std::string_view) and values.
template <internal::enums::is_scoped_enum EnumType>
constexpr auto get_enumerator_array() {
constexpr auto names = internal::enums::get_enum_names<
EnumType, internal::enums::is_flag_enum<EnumType>>();
constexpr auto names = internal::enums::
get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
return internal::enums::names_to_enumerator_array(names);
}
@ -56,8 +56,8 @@ namespace rfl {
// std::string_view) and underlying values.
template <internal::enums::is_scoped_enum EnumType>
constexpr auto get_underlying_enumerator_array() {
constexpr auto names = internal::enums::get_enum_names<
EnumType, internal::enums::is_flag_enum<EnumType>>();
constexpr auto names = internal::enums::
get_enum_names<EnumType, internal::enums::is_flag_enum<EnumType>>();
return internal::enums::names_to_underlying_enumerator_array(names);
}

12
include/rfl/flexbuf/Reader.hpp
View file

@ -49,7 +49,9 @@ namespace rfl {
) const noexcept {
const auto keys = _obj.Keys();
for (size_t i = 0; i < keys.size(); ++i) {
if (_name == keys[i].AsString().c_str()) { return _obj.Values()[i]; }
if (_name == keys[i].AsString().c_str()) {
return _obj.Values()[i];
}
}
return rfl::Error(
"Map does not contain any element called '" + _name + "'."
@ -95,7 +97,9 @@ namespace rfl {
const auto size = _arr.size();
for (size_t i = 0; i < size; ++i) {
const auto err = _array_reader.read(InputVarType(_arr[i]));
if (err) { return err; }
if (err) {
return err;
}
}
return std::nullopt;
}
@ -128,7 +132,9 @@ namespace rfl {
rfl::Result<InputObjectType> to_object(const InputVarType& _var
) const noexcept {
if (!_var.IsMap()) { return rfl::Error("Could not cast to Map!"); }
if (!_var.IsMap()) {
return rfl::Error("Could not cast to Map!");
}
return _var.AsMap();
}

6
include/rfl/from_named_tuple.hpp
View file

@ -17,7 +17,8 @@ namespace rfl {
auto from_named_tuple(NamedTupleType&& _n) {
using RequiredType = std::remove_cvref_t<rfl::named_tuple_t<T>>;
if constexpr (!std::is_same<
std::remove_cvref_t<NamedTupleType>, RequiredType>()) {
std::remove_cvref_t<NamedTupleType>,
RequiredType>()) {
return from_named_tuple<T>(RequiredType(std::forward<NamedTupleType>(_n))
);
} else if constexpr (internal::has_fields<T>()) {
@ -40,7 +41,8 @@ namespace rfl {
auto from_named_tuple(const NamedTupleType& _n) {
using RequiredType = std::remove_cvref_t<rfl::named_tuple_t<T>>;
if constexpr (!std::is_same<
std::remove_cvref_t<NamedTupleType>, RequiredType>()) {
std::remove_cvref_t<NamedTupleType>,
RequiredType>()) {
return from_named_tuple<T>(RequiredType(_n));
} else if constexpr (internal::has_fields<T>()) {
return internal::copy_from_named_tuple<T>(_n);

6
include/rfl/internal/Getter.hpp
View file

@ -42,7 +42,8 @@ namespace rfl::internal {
static_assert(
std::is_same<
typename std::tuple_element<
index, typename NamedTupleType::Fields>::type::Type,
index,
typename NamedTupleType::Fields>::type::Type,
typename Field::Type>(),
"If two fields have the same name, "
"their type must be the same as "
@ -73,7 +74,8 @@ namespace rfl::internal {
static_assert(
std::is_same<
typename std::tuple_element<
index, typename NamedTupleType::Fields>::type::Type,
index,
typename NamedTupleType::Fields>::type::Type,
typename Field::Type>(),
"If two fields have the same name, "
"their type must be the same as "

4
include/rfl/internal/StringLiteral.hpp
View file

@ -38,7 +38,9 @@ namespace rfl {
const StringLiteral<N1>& _first,
const StringLiteral<N2>& _second
) {
if constexpr (N1 != N2) { return false; }
if constexpr (N1 != N2) {
return false;
}
return _first.string_view() == _second.string_view();
}

15
include/rfl/internal/enums/get_enum_names.hpp
View file

@ -124,17 +124,26 @@ namespace rfl {
return NamesType {};
} else {
return get_enum_names_impl<
EnumType, NamesType, _max, _is_flag, _i + 1>();
EnumType,
NamesType,
_max,
_is_flag,
_i + 1>();
}
} else {
using NewNames = typename NamesType::template AddOneType<
Literal<remove_namespaces<name>()>, static_cast<EnumType>(j)>;
Literal<remove_namespaces<name>()>,
static_cast<EnumType>(j)>;
if constexpr (j == _max) {
return NewNames {};
} else {
return get_enum_names_impl<
EnumType, NewNames, _max, _is_flag, _i + 1>();
EnumType,
NewNames,
_max,
_is_flag,
_i + 1>();
}
}
}

3
include/rfl/internal/get_field_names.hpp
View file

@ -139,7 +139,8 @@ namespace rfl::internal {
const auto get = []<std::size_t... Is>(std::index_sequence<Is...>) {
return concat_literals(
get_field_name<
Type, wrap(std::get<Is>(bind_fake_object_to_tuple<T>()))>()...
Type,
wrap(std::get<Is>(bind_fake_object_to_tuple<T>()))>()...
);
};
#else

4
include/rfl/internal/get_type_name.hpp
View file

@ -29,7 +29,9 @@ namespace rfl {
auto split = func_name.substr(0, func_name.size() - 7);
split = split.substr(split.find("get_type_name_str_view<") + 23);
auto pos = split.find(" ");
if (pos != std::string_view::npos) { return split.substr(pos + 1); }
if (pos != std::string_view::npos) {
return split.substr(pos + 1);
}
return split;
#else
static_assert(

6
include/rfl/internal/move_and_flatten_field_tuple.hpp
View file

@ -18,14 +18,16 @@ namespace rfl {
using T = std::tuple_element_t<i, std::remove_cvref_t<FieldTuple>>;
if constexpr (is_flatten_field<T>::value) {
return move_and_flatten_field_tuple(
std::move(_t), std::move(_args)...,
std::move(_t),
std::move(_args)...,
move_and_flatten_field_tuple(
move_to_field_tuple(std::move(std::get<i>(_t).value_))
)
);
} else {
return move_and_flatten_field_tuple(
std::move(_t), std::move(_args)...,
std::move(_t),
std::move(_args)...,
std::make_tuple(std::move(std::get<i>(_t)))
);
}

10
include/rfl/internal/move_from_named_tuple.hpp
View file

@ -29,8 +29,8 @@ namespace rfl {
std::remove_cvref_t<std::remove_pointer_t<typename Field::Type>>;
if constexpr (is_named_tuple_v<T>) {
using SubPtrNamedTupleType = typename std::invoke_result<
decltype(nt_to_ptr_named_tuple<T>), T>::type;
using SubPtrNamedTupleType = typename std::
invoke_result<decltype(nt_to_ptr_named_tuple<T>), T>::type;
return make_ptr_fields<PtrFieldTupleType>(
_n, _args..., SubPtrNamedTupleType(_n).fields()
@ -63,7 +63,8 @@ namespace rfl {
if constexpr (is_field_v<FieldType>) {
return move_from_ptr_fields<T>(
_ptrs, std::move(_args)...,
_ptrs,
std::move(_args)...,
rfl::make_field<FieldType::name_>(
std::move(*std::get<i>(_ptrs).value())
)
@ -76,7 +77,8 @@ namespace rfl {
typename std::tuple_element_t<i, PtrFieldTupleType>::Type>>;
return move_from_ptr_fields<T>(
_ptrs, std::move(_args)...,
_ptrs,
std::move(_args)...,
move_from_ptr_fields<U>(std::get<i>(_ptrs))
);
}

10
include/rfl/internal/move_from_tuple.hpp
View file

@ -54,8 +54,11 @@ namespace rfl {
calc_flattened_size<SubTargetTupleType>();
return unflatten_ptr_tuple<
TargetTupleType, PtrTupleType, _j + flattened_size>(
_t, _args...,
TargetTupleType,
PtrTupleType,
_j + flattened_size>(
_t,
_args...,
unflatten_ptr_tuple<SubTargetTupleType, PtrTupleType, _j>(_t)
);
@ -88,7 +91,8 @@ namespace rfl {
typename std::tuple_element_t<i, PtrTupleType>>::Type>;
return move_from_pointers<T>(
_ptrs, std::move(_args)...,
_ptrs,
std::move(_args)...,
move_from_pointers<U>(std::get<i>(_ptrs))
);
}

3
include/rfl/internal/nt_to_ptr_named_tuple.hpp
View file

@ -45,7 +45,8 @@ namespace rfl {
using FieldType = typename std::tuple_element<i, Fields>::type;
using T = std::remove_cvref_t<typename FieldType::Type>;
return nt_to_ptr_named_tuple(
_nt, _a...,
_nt,
_a...,
Field<FieldType::name_, const T*>(&std::get<i>(_nt.values()))
);
}

9
include/rfl/internal/num_fields.hpp
View file

@ -83,11 +83,13 @@ namespace rfl {
template <std::size_t l, std::size_t nested, std::size_t r>
static consteval bool constructible_with_nested() {
return
[]<std::size_t... i, std::size_t... j,
[]<std::size_t... i,
std::size_t... j,
std::
size_t... k>(std::index_sequence<i...>, std::index_sequence<j...>, std::index_sequence<k...>) {
return requires { T {any(i)..., {any(j)...}, any(k)...}; };
}(std::make_index_sequence<l>(), std::make_index_sequence<nested>(),
}(std::make_index_sequence<l>(),
std::make_index_sequence<nested>(),
std::make_index_sequence<r>());
}
@ -122,7 +124,8 @@ namespace rfl {
std::
size_t... r>(std::index_sequence<l...>, std::index_sequence<r...>) {
return requires {
T {any_empty_base<T>(l)..., any_base<T>(0),
T {any_empty_base<T>(l)...,
any_base<T>(0),
any_empty_base<T>(r)...};
};
};

4
include/rfl/internal/remove_namespaces.hpp
View file

@ -14,7 +14,9 @@ namespace rfl {
consteval auto remove_namespaces() {
constexpr auto name = _name.string_view();
constexpr size_t pos = name.find_last_of(":");
if constexpr (pos == std::string_view::npos) { return _name; }
if constexpr (pos == std::string_view::npos) {
return _name;
}
constexpr auto substr = name.substr(pos + 1);
const auto to_str_lit = [&]<auto... Ns>(std::index_sequence<Ns...>) {
return StringLiteral<sizeof...(Ns) + 1> {substr[Ns]...};

4
include/rfl/internal/strings/join.hpp
View file

@ -13,7 +13,9 @@ namespace rfl {
const std::string& _delimiter,
const std::vector<std::string>& _strings
) {
if (_strings.size() == 0) { return ""; }
if (_strings.size() == 0) {
return "";
}
auto res = _strings[0];
for (size_t i = 1; i < _strings.size(); ++i) {
res += _delimiter + _strings[i];

6
include/rfl/internal/to_flattened_ptr_tuple.hpp
View file

@ -22,12 +22,14 @@ namespace rfl {
using T = std::tuple_element_t<i, std::remove_cvref_t<PtrTuple>>;
if constexpr (is_flatten_field_v<T>) {
return flatten_ptr_tuple(
std::forward<PtrTuple>(_t), std::forward<Args>(_args)...,
std::forward<PtrTuple>(_t),
std::forward<Args>(_args)...,
flatten_ptr_tuple(to_ptr_tuple(std::get<i>(_t)->get()))
);
} else {
return flatten_ptr_tuple(
std::forward<PtrTuple>(_t), std::forward<Args>(_args)...,
std::forward<PtrTuple>(_t),
std::forward<Args>(_args)...,
std::make_tuple(std::get<i>(_t))
);
}

3
include/rfl/internal/to_ptr_named_tuple.hpp
View file

@ -30,7 +30,8 @@ namespace rfl {
if constexpr (internal::is_flatten_field<T>::value) {
auto subtuple = internal::to_ptr_field_tuple(*std::get<i>(_t).get());
return flatten_ptr_field_tuple(
_t, std::forward<Args>(_args)...,
_t,
std::forward<Args>(_args)...,
flatten_ptr_field_tuple(subtuple)
);
} else {

12
include/rfl/internal/transform_snake_case.hpp
View file

@ -30,10 +30,18 @@ namespace rfl::internal {
return transform_snake_case<_name, false, _name.arr_.size(), chars...>();
} else if constexpr (_capitalize) {
return transform_snake_case<
_name, false, _i + 1, chars..., to_upper<_name.arr_[_i]>()>();
_name,
false,
_i + 1,
chars...,
to_upper<_name.arr_[_i]>()>();
} else {
return transform_snake_case<
_name, false, _i + 1, chars..., _name.arr_[_i]>();
_name,
false,
_i + 1,
chars...,
_name.arr_[_i]>();
}
}
} // namespace rfl::internal

8
include/rfl/json/Reader.hpp
View file

@ -71,7 +71,9 @@ namespace rfl {
yyjson_arr_iter_init(_arr.val_, &iter);
while ((val = yyjson_arr_iter_next(&iter))) {
const auto err = _array_reader.read(InputVarType(val));
if (err) { return err; }
if (err) {
return err;
}
}
return std::nullopt;
}
@ -95,7 +97,9 @@ namespace rfl {
rfl::Result<T> to_basic_type(const InputVarType _var) const noexcept {
if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
const auto r = yyjson_get_str(_var.val_);
if (r == NULL) { return rfl::Error("Could not cast to string."); }
if (r == NULL) {
return rfl::Error("Could not cast to string.");
}
return std::string(r);
} else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
if (!yyjson_is_bool(_var.val_)) {

4
include/rfl/json/read.hpp
View file

@ -28,7 +28,9 @@ namespace rfl {
Result<internal::wrap_in_rfl_array_t<T>> read(const std::string& _json_str
) {
yyjson_doc* doc = yyjson_read(_json_str.c_str(), _json_str.size(), 0);
if (!doc) { return Error("Could not parse document"); }
if (!doc) {
return Error("Could not parse document");
}
yyjson_val* root = yyjson_doc_get_root(doc);
const auto r = Reader();
auto res = Parser<T, Processors<Ps...>>::read(r, InputVarType(root));

4
include/rfl/json/to_schema.hpp
View file

@ -225,7 +225,9 @@ namespace rfl::json {
auto required = std::vector<std::string>();
for (const auto& [k, v] : _t.types_) {
properties[k] = type_to_json_schema_type(v);
if (!is_optional(v)) { required.push_back(k); }
if (!is_optional(v)) {
required.push_back(k);
}
}
return schema::Type {
.value =

8
include/rfl/msgpack/Reader.hpp
View file

@ -45,7 +45,9 @@ namespace rfl {
}
const auto current_name =
std::string_view(key.via.str.ptr, key.via.str.size);
if (_name == current_name) { return _obj.ptr[i].val; }
if (_name == current_name) {
return _obj.ptr[i].val;
}
}
return Error("No field named '" + _name + "' was found.");
}
@ -111,7 +113,9 @@ namespace rfl {
) const noexcept {
for (uint32_t i = 0; i < _arr.size; ++i) {
const auto err = _array_reader.read(_arr.ptr[i]);
if (err) { return err; }
if (err) {
return err;
}
}
return std::nullopt;
}

4
include/rfl/parsing/FieldVariantParser.hpp
View file

@ -45,7 +45,9 @@ namespace rfl {
&_r, &field_variant
);
auto err = _r.read_object(reader, _obj);
if (err) { return *err; }
if (err) {
return *err;
}
if (!field_variant) {
return Error(
"Could not parse: Expected the object to have "

8
include/rfl/parsing/MapParser.hpp
View file

@ -97,8 +97,12 @@ namespace rfl {
const auto map_reader =
MapReader<R, W, MapType, ProcessorsType>(&_r, &map, &errors);
const auto err = _r.read_object(map_reader, _obj);
if (err) { return *err; }
if (errors.size() != 0) { return to_single_error_message(errors); }
if (err) {
return *err;
}
if (errors.size() != 0) {
return to_single_error_message(errors);
}
return map;
}
};

21
include/rfl/parsing/NamedTupleParser.hpp
View file

@ -65,7 +65,9 @@ namespace rfl {
using ViewType = std::remove_cvref_t<decltype(view)>;
const auto err =
Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
if (err) [[unlikely]] { return *err; }
if (err) [[unlikely]] {
return *err;
}
return *ptr;
}
@ -76,7 +78,9 @@ namespace rfl {
NamedTuple<FieldTypes...>* _view
) noexcept {
auto obj = _r.to_object(_var);
if (!obj) [[unlikely]] { return obj.error(); }
if (!obj) [[unlikely]] {
return obj.error();
}
return read_object(_r, *obj, _view);
}
@ -106,8 +110,8 @@ namespace rfl {
if constexpr (_i == size) {
return Type {Type::Object {_values}};
} else {
using F = std::tuple_element_t<
_i, typename NamedTuple<FieldTypes...>::Fields>;
using F = std::
tuple_element_t<_i, typename NamedTuple<FieldTypes...>::Fields>;
using U = typename F::Type;
if constexpr (!internal::is_skip_v<U>) {
_values[std::string(F::name())] =
@ -217,9 +221,14 @@ namespace rfl {
&_r, _view, &found, &set, &errors
);
const auto err = _r.read_object(object_reader, _obj);
if (err) { return *err; }
if (err) {
return *err;
}
handle_missing_fields(
found, *_view, &set, &errors,
found,
*_view,
&set,
&errors,
std::make_integer_sequence<int, size_>()
);
if (errors.size() != 0) {

7
include/rfl/parsing/Parser_default.hpp
View file

@ -165,7 +165,8 @@ namespace rfl {
.description_ = typename U::Content().str(),
.type_ =
Ref<Type>::make(Parser<
R, W, std::remove_cvref_t<typename U::Type>,
R, W,
std::remove_cvref_t<typename U::Type>,
ProcessorsType>::to_schema(_definitions))
}
};
@ -244,7 +245,9 @@ namespace rfl {
using ViewType = std::remove_cvref_t<decltype(view)>;
const auto err =
Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
if (err) [[unlikely]] { return *err; }
if (err) [[unlikely]] {
return *err;
}
return std::move(*ptr);
}

4
include/rfl/parsing/Parser_optional.hpp
View file

@ -25,7 +25,9 @@ namespace rfl {
static Result<std::optional<T>>
read(const R& _r, const InputVarType& _var) noexcept {
if (_r.is_empty(_var)) { return std::optional<T>(); }
if (_r.is_empty(_var)) {
return std::optional<T>();
}
const auto to_opt = [](auto&& _t) { return std::make_optional<T>(_t); };
return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
_r, _var

4
include/rfl/parsing/Parser_pair.hpp
View file

@ -46,7 +46,9 @@ namespace rfl {
) noexcept {
const auto tup = std::make_tuple(&_p.first, &_p.second);
Parser<
R, W, std::tuple<const FirstType*, const SecondType*>,
R,
W,
std::tuple<const FirstType*, const SecondType*>,
ProcessorsType>::write(_w, tup, _parent);
}

4
include/rfl/parsing/Parser_shared_ptr.hpp
View file

@ -24,7 +24,9 @@ namespace rfl::parsing {
static Result<std::shared_ptr<T>>
read(const R& _r, const InputVarType& _var) noexcept {
if (_r.is_empty(_var)) { return std::shared_ptr<T>(); }
if (_r.is_empty(_var)) {
return std::shared_ptr<T>();
}
const auto to_ptr = [](auto&& _t) {
return std::make_shared<T>(std::move(_t));
};

9
include/rfl/parsing/Parser_skip.hpp
View file

@ -41,8 +41,9 @@ namespace rfl {
);
} else {
const auto to_skip = [&](auto&& _t) {
return internal::Skip<
T, _skip_serialization, _skip_deserialization>(std::move(_t));
return internal::
Skip<T, _skip_serialization, _skip_deserialization>(std::move(_t
));
};
return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(
_r, _var
@ -60,7 +61,9 @@ namespace rfl {
) noexcept {
if constexpr (_skip_serialization) {
using ReflectionType = std::remove_cvref_t<typename internal::Skip<
T, _skip_serialization, _skip_deserialization>::ReflectionType>;
T,
_skip_serialization,
_skip_deserialization>::ReflectionType>;
Parser<R, W, ReflectionType, ProcessorsType>::write(
_w, ReflectionType(), _parent
);

10
include/rfl/parsing/Parser_tagged_union.hpp
View file

@ -82,8 +82,8 @@ namespace rfl {
const InputVarType& _var
) noexcept {
if constexpr (_i == sizeof...(AlternativeTypes)) {
const auto names = TaggedUnion<
_discriminator, AlternativeTypes...>::PossibleTags::names();
const auto names = TaggedUnion<_discriminator, AlternativeTypes...>::
PossibleTags::names();
return Error(
"Could not parse tagged union, could not match " +
_discriminator.str() + " '" + _disc_value +
@ -91,9 +91,9 @@ namespace rfl {
internal::strings::join(",", names)
);
} else {
using AlternativeType =
std::remove_cvref_t<std::variant_alternative_t<
_i, std::variant<AlternativeTypes...>>>;
using AlternativeType = std::remove_cvref_t<
std::
variant_alternative_t<_i, std::variant<AlternativeTypes...>>>;
if (contains_disc_value<AlternativeType>(_disc_value)) {
const auto to_tagged_union = [](auto&& _val) {

4
include/rfl/parsing/Parser_unique_ptr.hpp
View file

@ -25,7 +25,9 @@ namespace rfl {
static Result<std::unique_ptr<T>>
read(const R& _r, const InputVarType& _var) noexcept {
if (_r.is_empty(_var)) { return std::unique_ptr<T>(); }
if (_r.is_empty(_var)) {
return std::unique_ptr<T>();
}
const auto to_ptr = [](auto&& _t) {
return std::make_unique<T>(std::move(_t));
};

4
include/rfl/parsing/Parser_variant.hpp
View file

@ -73,8 +73,8 @@ namespace rfl {
std::vector<schema::Type> _types = {}
) {
if constexpr (internal::all_fields<std::tuple<FieldTypes...>>()) {
return FieldVariantParser<
R, W, ProcessorsType, FieldTypes...>::to_schema(_definitions);
return FieldVariantParser<R, W, ProcessorsType, FieldTypes...>::
to_schema(_definitions);
} else {
using Type = schema::Type;
constexpr size_t size = sizeof...(FieldTypes);

4
include/rfl/parsing/Parser_wstring.hpp
View file

@ -24,7 +24,9 @@ namespace rfl {
static Result<std::wstring>
read(const R& _r, const InputVarType& _var) noexcept {
if (_r.is_empty(_var)) { return std::wstring(); }
if (_r.is_empty(_var)) {
return std::wstring();
}
auto inStr = Parser<R, W, std::string, ProcessorsType>::read(_r, _var);
if (auto err = inStr.error(); err.has_value()) {

6
include/rfl/parsing/TupleParser.hpp
View file

@ -38,7 +38,11 @@ namespace rfl::parsing {
alignas(std::tuple<Ts...>) unsigned char buf[sizeof(std::tuple<Ts...>)];
auto ptr = reinterpret_cast<std::tuple<Ts...>*>(buf);
const auto tuple_reader = TupleReader<
R, W, std::tuple<Ts...>, _ignore_empty_containers, _all_required,
R,
W,
std::tuple<Ts...>,
_ignore_empty_containers,
_all_required,
ProcessorsType>(&_r, ptr);
auto err = _r.read_array(tuple_reader, _arr);
if (err) {

8
include/rfl/parsing/TupleReader.hpp
View file

@ -31,7 +31,9 @@ namespace rfl::parsing {
std::optional<Error> handle_missing_fields() const {
std::optional<Error> err;
if (i_ < size_) { handle_missing_fields_impl(&err); }
if (i_ < size_) {
handle_missing_fields_impl(&err);
}
return err;
}
@ -46,7 +48,9 @@ namespace rfl::parsing {
template <size_t _i = 0>
void call_destructors_where_necessary() const {
if constexpr (_i < size_) {
if (_i >= i_) { return; }
if (_i >= i_) {
return;
}
using CurrentType =
std::remove_cvref_t<std::tuple_element_t<_i, TupleType>>;
if constexpr (!std::is_array_v<CurrentType> &&

4
include/rfl/parsing/VectorParser.hpp
View file

@ -61,7 +61,9 @@ namespace rfl {
auto vector_reader =
VectorReader<R, W, VecType, ProcessorsType>(&_r, &vec);
const auto err = _r.read_array(vector_reader, _arr);
if (err) { return *err; }
if (err) {
return *err;
}
return vec;
};
return _r.to_array(_var).and_then(parse);

4
include/rfl/parsing/VectorReader.hpp
View file

@ -48,7 +48,9 @@ namespace rfl::parsing {
using K = std::remove_cvref_t<typename T::first_type>;
using V = std::remove_cvref_t<typename T::second_type>;
return Parser<
R, W, std::remove_cvref_t<std::pair<K, V>>,
R,
W,
std::remove_cvref_t<std::pair<K, V>>,
ProcessorsType>::read(*r_, _var);
}

20
include/rfl/parsing/ViewReader.hpp
View file

@ -34,7 +34,13 @@ namespace rfl::parsing {
/// such a field exists in the underlying view.
void read(const std::string_view& _name, const InputVarType& _var) const {
assign_to_matching_field(
*r_, _name, _var, view_, errors_, found_, set_,
*r_,
_name,
_var,
view_,
errors_,
found_,
set_,
std::make_integer_sequence<int, size_>()
);
}
@ -90,7 +96,13 @@ namespace rfl::parsing {
assign_to_matching_field(const R& _r, const std::string_view& _current_name, const auto& _var, auto* _view, auto* _errors, auto* _found, auto* _set, std::integer_sequence<int, is...>) {
bool already_assigned = false;
(assign_if_field_matches<is>(
_r, _current_name, _var, _view, _errors, _found, _set,
_r,
_current_name,
_var,
_view,
_errors,
_found,
_set,
&already_assigned
),
...);
@ -116,7 +128,9 @@ namespace rfl::parsing {
if constexpr (!std::is_array_v<ValueType> &&
std::is_pointer_v<OriginalType> &&
std::is_destructible_v<ValueType>) {
if (std::get<_i>(*set_)) { rfl::get<_i>(*view_)->~ValueType(); }
if (std::get<_i>(*set_)) {
rfl::get<_i>(*view_)->~ValueType();
}
} else if constexpr (std::is_array_v<ValueType>) {
if (std::get<_i>(*set_)) {
auto ptr = rfl::get<_i>(*view_);

3
include/rfl/parsing/is_required.hpp
View file

@ -39,7 +39,8 @@ namespace rfl {
using Type = std::remove_cvref_t<std::remove_pointer_t<T>>;
if constexpr (internal::has_reflection_type_v<Type>) {
return is_required<
typename Type::ReflectionType, _ignore_empty_containers>();
typename Type::ReflectionType,
_ignore_empty_containers>();
} else if constexpr (internal::is_rename_v<Type>) {
return is_required<typename Type::Type, _ignore_empty_containers>();
} else {

28
include/rfl/toml/Reader.hpp
View file

@ -47,19 +47,27 @@ namespace rfl::toml {
rfl::Result<T> to_basic_type(const InputVarType& _var) const noexcept {
if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
const auto ptr = _var->as<std::string>();
if (!ptr) { return Error("Could not cast the node to std::string!"); }
if (!ptr) {
return Error("Could not cast the node to std::string!");
}
return **ptr;
} else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
const auto ptr = _var->as<bool>();
if (!ptr) { return Error("Could not cast the node to bool!"); }
if (!ptr) {
return Error("Could not cast the node to bool!");
}
return **ptr;
} else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>()) {
const auto ptr = _var->as<double>();
if (!ptr) { return Error("Could not cast the node to double!"); }
if (!ptr) {
return Error("Could not cast the node to double!");
}
return static_cast<std::remove_cvref_t<T>>(**ptr);
} else if constexpr (std::is_integral<std::remove_cvref_t<T>>()) {
const auto ptr = _var->as<int64_t>();
if (!ptr) { return Error("Could not cast the node to int64_t!"); }
if (!ptr) {
return Error("Could not cast the node to int64_t!");
}
return static_cast<std::remove_cvref_t<T>>(**ptr);
} else {
static_assert(rfl::always_false_v<T>, "Unsupported type.");
@ -69,7 +77,9 @@ namespace rfl::toml {
rfl::Result<InputArrayType> to_array(const InputVarType& _var
) const noexcept {
const auto ptr = _var->as_array();
if (!ptr) { return rfl::Error("Could not cast to an array!"); }
if (!ptr) {
return rfl::Error("Could not cast to an array!");
}
return ptr;
}
@ -80,7 +90,9 @@ namespace rfl::toml {
) const noexcept {
for (auto& node : *_arr) {
const auto err = _array_reader.read(&node);
if (err) { return err; }
if (err) {
return err;
}
}
return std::nullopt;
}
@ -99,7 +111,9 @@ namespace rfl::toml {
rfl::Result<InputObjectType> to_object(const InputVarType& _var
) const noexcept {
const auto ptr = _var->as_table();
if (!ptr) { return rfl::Error("Could not cast to a table!"); }
if (!ptr) {
return rfl::Error("Could not cast to a table!");
}
return ptr;
}

4
include/rfl/xml/Reader.hpp
View file

@ -142,7 +142,9 @@ namespace rfl {
const auto name = _arr.node_.name();
for (auto node = _arr.node_; node; node = node.next_sibling(name)) {
const auto err = _array_reader.read(InputVarType(node));
if (err) { return err; }
if (err) {
return err;
}
}
return std::nullopt;
}

4
include/rfl/yaml/Reader.hpp
View file

@ -91,7 +91,9 @@ namespace rfl {
) const noexcept {
for (size_t i = 0; i < _arr.node_.size(); ++i) {
const auto err = _array_reader.read(_arr.node_[i]);
if (err) { return err; }
if (err) {
return err;
}
}
return std::nullopt;
}

3
include/util/numtypes.h
View file

@ -1,7 +1,10 @@
#pragma once
#include <cstddef>
#include <cstdint>
#define fn auto
// Unsigned integers
using u8 = std::uint8_t;
using u16 = std::uint16_t;

346
include/yyjson.h
View file

@ -869,8 +869,10 @@ extern "C" {
size_t mul = (size_t)12 + !(flg & YYJSON_READ_INSITU);
size_t pad = 256;
size_t max = (size_t)(~(size_t)0);
if (flg & YYJSON_READ_STOP_WHEN_DONE) len = len < 256 ? 256 : len;
if (len >= (max - pad - mul) / mul) return 0;
if (flg & YYJSON_READ_STOP_WHEN_DONE)
len = len < 256 ? 256 : len;
if (len >= (max - pad - mul) / mul)
return 0;
return len * mul + pad;
}
@ -1757,9 +1759,11 @@ extern "C" {
@endcode
*/
#define yyjson_arr_foreach(arr, idx, max, val) \
for ((idx) = 0, (max) = yyjson_arr_size(arr), \
for ((idx) = 0, \
(max) = yyjson_arr_size(arr), \
(val) = yyjson_arr_get_first(arr); \
(idx) < (max); (idx)++, (val) = unsafe_yyjson_get_next(val))
(idx) < (max); \
(idx)++, (val) = unsafe_yyjson_get_next(val))
/*==============================================================================
* JSON Object API
@ -1923,8 +1927,10 @@ extern "C" {
@endcode
*/
#define yyjson_obj_foreach(obj, idx, max, key, val) \
for ((idx) = 0, (max) = yyjson_obj_size(obj), \
(key) = (obj) ? unsafe_yyjson_get_first(obj) : NULL, (val) = (key) + 1; \
for ((idx) = 0, \
(max) = yyjson_obj_size(obj), \
(key) = (obj) ? unsafe_yyjson_get_first(obj) : NULL, \
(val) = (key) + 1; \
(idx) < (max); \
(idx)++, (key) = unsafe_yyjson_get_next(val), (val) = (key) + 1)
@ -2444,9 +2450,11 @@ extern "C" {
@endcode
*/
#define yyjson_mut_arr_foreach(arr, idx, max, val) \
for ((idx) = 0, (max) = yyjson_mut_arr_size(arr), \
for ((idx) = 0, \
(max) = yyjson_mut_arr_size(arr), \
(val) = yyjson_mut_arr_get_first(arr); \
(idx) < (max); (idx)++, (val) = (val)->next)
(idx) < (max); \
(idx)++, (val) = (val)->next)
/*==============================================================================
* Mutable JSON Array Creation API
@ -3358,10 +3366,12 @@ extern "C" {
@endcode
*/
#define yyjson_mut_obj_foreach(obj, idx, max, key, val) \
for ((idx) = 0, (max) = yyjson_mut_obj_size(obj), \
for ((idx) = 0, \
(max) = yyjson_mut_obj_size(obj), \
(key) = (max) ? ((yyjson_mut_val*)(obj)->uni.ptr)->next->next : NULL, \
(val) = (key) ? (key)->next : NULL; \
(idx) < (max); (idx)++, (key) = (val)->next, (val) = (key)->next)
(idx) < (max); \
(idx)++, (key) = (val)->next, (val) = (key)->next)
/*==============================================================================
* Mutable JSON Object Creation API
@ -4823,7 +4833,8 @@ extern "C" {
yyjson_api_inline void yyjson_doc_free(yyjson_doc* doc) {
if (doc) {
yyjson_alc alc = doc->alc;
if (doc->str_pool) alc.free(alc.ctx, doc->str_pool);
if (doc->str_pool)
alc.free(alc.ctx, doc->str_pool);
alc.free(alc.ctx, doc);
}
}
@ -4985,64 +4996,76 @@ extern "C" {
yyjson_api bool unsafe_yyjson_equals(yyjson_val* lhs, yyjson_val* rhs);
yyjson_api_inline bool yyjson_equals(yyjson_val* lhs, yyjson_val* rhs) {
if (yyjson_unlikely(!lhs || !rhs)) return false;
if (yyjson_unlikely(!lhs || !rhs))
return false;
return unsafe_yyjson_equals(lhs, rhs);
}
yyjson_api_inline bool
yyjson_set_raw(yyjson_val* val, const char* raw, size_t len) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
unsafe_yyjson_set_raw(val, raw, len);
return true;
}
yyjson_api_inline bool yyjson_set_null(yyjson_val* val) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
unsafe_yyjson_set_null(val);
return true;
}
yyjson_api_inline bool yyjson_set_bool(yyjson_val* val, bool num) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
unsafe_yyjson_set_bool(val, num);
return true;
}
yyjson_api_inline bool yyjson_set_uint(yyjson_val* val, uint64_t num) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
unsafe_yyjson_set_uint(val, num);
return true;
}
yyjson_api_inline bool yyjson_set_sint(yyjson_val* val, int64_t num) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
unsafe_yyjson_set_sint(val, num);
return true;
}
yyjson_api_inline bool yyjson_set_int(yyjson_val* val, int num) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
unsafe_yyjson_set_sint(val, (int64_t)num);
return true;
}
yyjson_api_inline bool yyjson_set_real(yyjson_val* val, double num) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
unsafe_yyjson_set_real(val, num);
return true;
}
yyjson_api_inline bool yyjson_set_str(yyjson_val* val, const char* str) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!str)) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
if (yyjson_unlikely(!str))
return false;
unsafe_yyjson_set_str(val, str);
return true;
}
yyjson_api_inline bool
yyjson_set_strn(yyjson_val* val, const char* str, size_t len) {
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false;
if (yyjson_unlikely(!str)) return false;
if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val)))
return false;
if (yyjson_unlikely(!str))
return false;
unsafe_yyjson_set_strn(val, str, len);
return true;
}
@ -5107,7 +5130,8 @@ extern "C" {
iter->cur = unsafe_yyjson_get_first(arr);
return true;
}
if (iter) memset(iter, 0, sizeof(yyjson_arr_iter));
if (iter)
memset(iter, 0, sizeof(yyjson_arr_iter));
return false;
}
@ -5174,7 +5198,8 @@ extern "C" {
iter->obj = obj;
return true;
}
if (iter) memset(iter, 0, sizeof(yyjson_obj_iter));
if (iter)
memset(iter, 0, sizeof(yyjson_obj_iter));
return false;
}
@ -5333,7 +5358,8 @@ extern "C" {
yyjson_api_inline char*
unsafe_yyjson_mut_strncpy(yyjson_mut_doc* doc, const char* str, size_t len) {
char* mem = unsafe_yyjson_mut_str_alc(doc, len);
if (yyjson_unlikely(!mem)) return NULL;
if (yyjson_unlikely(!mem))
return NULL;
memcpy((void*)mem, (const void*)str, len);
mem[len] = '\0';
return mem;
@ -5365,7 +5391,8 @@ extern "C" {
yyjson_api_inline void
yyjson_mut_doc_set_root(yyjson_mut_doc* doc, yyjson_mut_val* root) {
if (doc) doc->root = root;
if (doc)
doc->root = root;
}
/*==============================================================================
@ -5499,76 +5526,88 @@ extern "C" {
yyjson_api_inline bool
yyjson_mut_equals(yyjson_mut_val* lhs, yyjson_mut_val* rhs) {
if (yyjson_unlikely(!lhs || !rhs)) return false;
if (yyjson_unlikely(!lhs || !rhs))
return false;
return unsafe_yyjson_mut_equals(lhs, rhs);
}
yyjson_api_inline bool
yyjson_mut_set_raw(yyjson_mut_val* val, const char* raw, size_t len) {
if (yyjson_unlikely(!val || !raw)) return false;
if (yyjson_unlikely(!val || !raw))
return false;
unsafe_yyjson_set_raw(val, raw, len);
return true;
}
yyjson_api_inline bool yyjson_mut_set_null(yyjson_mut_val* val) {
if (yyjson_unlikely(!val)) return false;
if (yyjson_unlikely(!val))
return false;
unsafe_yyjson_set_null(val);
return true;
}
yyjson_api_inline bool yyjson_mut_set_bool(yyjson_mut_val* val, bool num) {
if (yyjson_unlikely(!val)) return false;
if (yyjson_unlikely(!val))
return false;
unsafe_yyjson_set_bool(val, num);
return true;
}
yyjson_api_inline bool
yyjson_mut_set_uint(yyjson_mut_val* val, uint64_t num) {
if (yyjson_unlikely(!val)) return false;
if (yyjson_unlikely(!val))
return false;
unsafe_yyjson_set_uint(val, num);
return true;
}
yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val* val, int64_t num) {
if (yyjson_unlikely(!val)) return false;
if (yyjson_unlikely(!val))
return false;
unsafe_yyjson_set_sint(val, num);
return true;
}
yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val* val, int num) {
if (yyjson_unlikely(!val)) return false;
if (yyjson_unlikely(!val))
return false;
unsafe_yyjson_set_sint(val, (int64_t)num);
return true;
}
yyjson_api_inline bool yyjson_mut_set_real(yyjson_mut_val* val, double num) {
if (yyjson_unlikely(!val)) return false;
if (yyjson_unlikely(!val))
return false;
unsafe_yyjson_set_real(val, num);
return true;
}
yyjson_api_inline bool
yyjson_mut_set_str(yyjson_mut_val* val, const char* str) {
if (yyjson_unlikely(!val || !str)) return false;
if (yyjson_unlikely(!val || !str))
return false;
unsafe_yyjson_set_str(val, str);
return true;
}
yyjson_api_inline bool
yyjson_mut_set_strn(yyjson_mut_val* val, const char* str, size_t len) {
if (yyjson_unlikely(!val || !str)) return false;
if (yyjson_unlikely(!val || !str))
return false;
unsafe_yyjson_set_strn(val, str, len);
return true;
}
yyjson_api_inline bool yyjson_mut_set_arr(yyjson_mut_val* val) {
if (yyjson_unlikely(!val)) return false;
if (yyjson_unlikely(!val))
return false;
unsafe_yyjson_set_arr(val, 0);
return true;
}
yyjson_api_inline bool yyjson_mut_set_obj(yyjson_mut_val* val) {
if (yyjson_unlikely(!val)) return false;
if (yyjson_unlikely(!val))
return false;
unsafe_yyjson_set_obj(val, 0);
return true;
}
@ -5579,7 +5618,8 @@ extern "C" {
yyjson_api_inline yyjson_mut_val*
yyjson_mut_raw(yyjson_mut_doc* doc, const char* str) {
if (yyjson_likely(str)) return yyjson_mut_rawn(doc, str, strlen(str));
if (yyjson_likely(str))
return yyjson_mut_rawn(doc, str, strlen(str));
return NULL;
}
@ -5598,7 +5638,8 @@ extern "C" {
yyjson_api_inline yyjson_mut_val*
yyjson_mut_rawcpy(yyjson_mut_doc* doc, const char* str) {
if (yyjson_likely(str)) return yyjson_mut_rawncpy(doc, str, strlen(str));
if (yyjson_likely(str))
return yyjson_mut_rawncpy(doc, str, strlen(str));
return NULL;
}
@ -5707,7 +5748,8 @@ extern "C" {
yyjson_api_inline yyjson_mut_val*
yyjson_mut_str(yyjson_mut_doc* doc, const char* str) {
if (yyjson_likely(str)) return yyjson_mut_strn(doc, str, strlen(str));
if (yyjson_likely(str))
return yyjson_mut_strn(doc, str, strlen(str));
return NULL;
}
@ -5726,7 +5768,8 @@ extern "C" {
yyjson_api_inline yyjson_mut_val*
yyjson_mut_strcpy(yyjson_mut_doc* doc, const char* str) {
if (yyjson_likely(str)) return yyjson_mut_strncpy(doc, str, strlen(str));
if (yyjson_likely(str))
return yyjson_mut_strncpy(doc, str, strlen(str));
return NULL;
}
@ -5792,7 +5835,8 @@ extern "C" {
iter->arr = arr;
return true;
}
if (iter) memset(iter, 0, sizeof(yyjson_mut_arr_iter));
if (iter)
memset(iter, 0, sizeof(yyjson_mut_arr_iter));
return false;
}
@ -5828,7 +5872,8 @@ extern "C" {
yyjson_mut_val* prev = iter->pre;
yyjson_mut_val* cur = iter->cur;
yyjson_mut_val* next = cur->next;
if (yyjson_unlikely(iter->idx == iter->max)) iter->arr->uni.ptr = prev;
if (yyjson_unlikely(iter->idx == iter->max))
iter->arr->uni.ptr = prev;
iter->idx--;
iter->max--;
unsafe_yyjson_set_len(iter->arr, iter->max);
@ -6030,7 +6075,8 @@ extern "C" {
uint64_t len = (uint64_t)strlen(vals[i]);
val->tag = (len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
val->uni.str = vals[i];
if (yyjson_unlikely(!val->uni.str)) return NULL;
if (yyjson_unlikely(!val->uni.str))
return NULL;
});
}
@ -6040,11 +6086,13 @@ extern "C" {
const size_t* lens,
size_t count
) {
if (yyjson_unlikely(count > 0 && !lens)) return NULL;
if (yyjson_unlikely(count > 0 && !lens))
return NULL;
yyjson_mut_arr_with_func({
val->tag = ((uint64_t)lens[i] << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
val->uni.str = vals[i];
if (yyjson_unlikely(!val->uni.str)) return NULL;
if (yyjson_unlikely(!val->uni.str))
return NULL;
});
}
@ -6057,11 +6105,13 @@ extern "C" {
const char* str;
yyjson_mut_arr_with_func({
str = vals[i];
if (!str) return NULL;
if (!str)
return NULL;
len = strlen(str);
val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len);
if (yyjson_unlikely(!val->uni.str)) return NULL;
if (yyjson_unlikely(!val->uni.str))
return NULL;
});
}
@ -6073,13 +6123,15 @@ extern "C" {
) {
size_t len;
const char* str;
if (yyjson_unlikely(count > 0 && !lens)) return NULL;
if (yyjson_unlikely(count > 0 && !lens))
return NULL;
yyjson_mut_arr_with_func({
str = vals[i];
len = lens[i];
val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len);
if (yyjson_unlikely(!val->uni.str)) return NULL;
if (yyjson_unlikely(!val->uni.str))
return NULL;
});
}
@ -6172,7 +6224,8 @@ extern "C" {
}
prev->next = val;
val->next = next->next;
if ((void*)next == arr->uni.ptr) arr->uni.ptr = val;
if ((void*)next == arr->uni.ptr)
arr->uni.ptr = val;
return next;
} else {
yyjson_mut_val* prev = ((yyjson_mut_val*)arr->uni.ptr);
@ -6199,7 +6252,8 @@ extern "C" {
next = next->next;
}
prev->next = next->next;
if ((void*)next == arr->uni.ptr) arr->uni.ptr = prev;
if ((void*)next == arr->uni.ptr)
arr->uni.ptr = prev;
return next;
} else {
return ((yyjson_mut_val*)arr->uni.ptr);
@ -6258,17 +6312,21 @@ extern "C" {
yyjson_mut_val *prev, *next;
bool tail_removed;
size_t len = unsafe_yyjson_get_len(arr);
if (yyjson_unlikely(_idx + _len > len)) return false;
if (yyjson_unlikely(_len == 0)) return true;
if (yyjson_unlikely(_idx + _len > len))
return false;
if (yyjson_unlikely(_len == 0))
return true;
unsafe_yyjson_set_len(arr, len - _len);
if (yyjson_unlikely(len == _len)) return true;
if (yyjson_unlikely(len == _len))
return true;
tail_removed = (_idx + _len == len);
prev = ((yyjson_mut_val*)arr->uni.ptr);
while (_idx-- > 0) prev = prev->next;
next = prev->next;
while (_len-- > 0) next = next->next;
prev->next = next;
if (yyjson_unlikely(tail_removed)) arr->uni.ptr = prev;
if (yyjson_unlikely(tail_removed))
arr->uni.ptr = prev;
return true;
}
return false;
@ -6499,7 +6557,8 @@ extern "C" {
iter->obj = obj;
return true;
}
if (iter) memset(iter, 0, sizeof(yyjson_mut_obj_iter));
if (iter)
memset(iter, 0, sizeof(yyjson_mut_obj_iter));
return false;
}
@ -6541,7 +6600,8 @@ extern "C" {
yyjson_mut_val* prev = iter->pre;
yyjson_mut_val* cur = iter->cur;
yyjson_mut_val* next = cur->next->next;
if (yyjson_unlikely(iter->idx == iter->max)) iter->obj->uni.ptr = prev;
if (yyjson_unlikely(iter->idx == iter->max))
iter->obj->uni.ptr = prev;
iter->idx--;
iter->max--;
unsafe_yyjson_set_len(iter->obj, iter->max);
@ -6572,7 +6632,8 @@ extern "C" {
if (unsafe_yyjson_get_len(cur) == key_len &&
memcmp(cur->uni.str, key, key_len) == 0) {
iter->idx += idx;
if (iter->idx > max) iter->idx -= max + 1;
if (iter->idx > max)
iter->idx -= max + 1;
iter->pre = pre;
iter->cur = cur;
return cur->next;
@ -6702,10 +6763,12 @@ extern "C" {
for (i = 0; i < obj_len; i++) {
if (key_tag == cur_key->tag &&
memcmp(key, cur_key->uni.ptr, key_len) == 0) {
if (!removed_item) removed_item = cur_key->next;
if (!removed_item)
removed_item = cur_key->next;
cur_key = cur_key->next->next;
pre_key->next->next = cur_key;
if (i + 1 == obj_len) obj->uni.ptr = pre_key;
if (i + 1 == obj_len)
obj->uni.ptr = pre_key;
i--;
obj_len--;
} else {
@ -6791,7 +6854,8 @@ extern "C" {
}
}
}
if (!replaced && val) unsafe_yyjson_mut_obj_add(obj, key, val, iter.max);
if (!replaced && val)
unsafe_yyjson_mut_obj_add(obj, key, val, iter.max);
return true;
}
@ -6998,7 +7062,8 @@ extern "C" {
const char* _key,
const char* _val
) {
if (yyjson_unlikely(!_val)) return false;
if (yyjson_unlikely(!_val))
return false;
yyjson_mut_obj_add_func({
val->tag = ((uint64_t)strlen(_val) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
val->uni.str = _val;
@ -7012,7 +7077,8 @@ extern "C" {
const char* _val,
size_t _len
) {
if (yyjson_unlikely(!_val)) return false;
if (yyjson_unlikely(!_val))
return false;
yyjson_mut_obj_add_func({
val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
val->uni.str = _val;
@ -7025,11 +7091,13 @@ extern "C" {
const char* _key,
const char* _val
) {
if (yyjson_unlikely(!_val)) return false;
if (yyjson_unlikely(!_val))
return false;
yyjson_mut_obj_add_func({
size_t _len = strlen(_val);
val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len);
if (yyjson_unlikely(!val->uni.str)) return false;
if (yyjson_unlikely(!val->uni.str))
return false;
val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
});
}
@ -7041,10 +7109,12 @@ extern "C" {
const char* _val,
size_t _len
) {
if (yyjson_unlikely(!_val)) return false;
if (yyjson_unlikely(!_val))
return false;
yyjson_mut_obj_add_func({
val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len);
if (yyjson_unlikely(!val->uni.str)) return false;
if (yyjson_unlikely(!val->uni.str))
return false;
val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR;
});
}
@ -7055,7 +7125,8 @@ extern "C" {
const char* _key,
yyjson_mut_val* _val
) {
if (yyjson_unlikely(!_val)) return false;
if (yyjson_unlikely(!_val))
return false;
yyjson_mut_obj_add_func({ val = _val; });
}
@ -7077,7 +7148,8 @@ extern "C" {
while ((key = yyjson_mut_obj_iter_next(&iter)) != NULL) {
if (unsafe_yyjson_get_len(key) == _len &&
memcmp(key->uni.str, _key, _len) == 0) {
if (!val_removed) val_removed = key->next;
if (!val_removed)
val_removed = key->next;
yyjson_mut_obj_iter_remove(&iter);
}
}
@ -7092,7 +7164,8 @@ extern "C" {
const char* key,
const char* new_key
) {
if (!key || !new_key) return false;
if (!key || !new_key)
return false;
return yyjson_mut_obj_rename_keyn(
doc, obj, key, strlen(key), new_key, strlen(new_key)
);
@ -7109,13 +7182,15 @@ extern "C" {
char* cpy_key = NULL;
yyjson_mut_val* old_key;
yyjson_mut_obj_iter iter;
if (!doc || !obj || !key || !new_key) return false;
if (!doc || !obj || !key || !new_key)
return false;
yyjson_mut_obj_iter_init(obj, &iter);
while ((old_key = yyjson_mut_obj_iter_next(&iter))) {
if (unsafe_yyjson_equals_strn((void*)old_key, key, len)) {
if (!cpy_key) {
cpy_key = unsafe_yyjson_mut_strncpy(doc, new_key, new_len);
if (!cpy_key) return false;
if (!cpy_key)
return false;
}
yyjson_mut_set_strn(old_key, cpy_key, new_len);
}
@ -7187,7 +7262,8 @@ extern "C" {
yyjson_api_inline yyjson_val*
yyjson_doc_ptr_get(yyjson_doc* doc, const char* ptr) {
if (yyjson_unlikely(!ptr)) return NULL;
if (yyjson_unlikely(!ptr))
return NULL;
return yyjson_doc_ptr_getn(doc, ptr, strlen(ptr));
}
@ -7211,7 +7287,9 @@ extern "C" {
yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
return NULL;
}
if (yyjson_unlikely(len == 0)) { return doc->root; }
if (yyjson_unlikely(len == 0)) {
return doc->root;
}
if (yyjson_unlikely(*ptr != '/')) {
yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
return NULL;
@ -7221,7 +7299,8 @@ extern "C" {
yyjson_api_inline yyjson_val*
yyjson_ptr_get(yyjson_val* val, const char* ptr) {
if (yyjson_unlikely(!ptr)) return NULL;
if (yyjson_unlikely(!ptr))
return NULL;
return yyjson_ptr_getn(val, ptr, strlen(ptr));
}
@ -7241,7 +7320,9 @@ extern "C" {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
return NULL;
}
if (yyjson_unlikely(len == 0)) { return val; }
if (yyjson_unlikely(len == 0)) {
return val;
}
if (yyjson_unlikely(*ptr != '/')) {
yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
return NULL;
@ -7251,7 +7332,8 @@ extern "C" {
yyjson_api_inline yyjson_mut_val*
yyjson_mut_doc_ptr_get(yyjson_mut_doc* doc, const char* ptr) {
if (!ptr) return NULL;
if (!ptr)
return NULL;
return yyjson_mut_doc_ptr_getn(doc, ptr, strlen(ptr));
}
@ -7268,7 +7350,8 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!doc || !ptr)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@ -7278,7 +7361,9 @@ extern "C" {
yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL");
return NULL;
}
if (yyjson_unlikely(len == 0)) { return doc->root; }
if (yyjson_unlikely(len == 0)) {
return doc->root;
}
if (yyjson_unlikely(*ptr != '/')) {
yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
return NULL;
@ -7288,7 +7373,8 @@ extern "C" {
yyjson_api_inline yyjson_mut_val*
yyjson_mut_ptr_get(yyjson_mut_val* val, const char* ptr) {
if (!ptr) return NULL;
if (!ptr)
return NULL;
return yyjson_mut_ptr_getn(val, ptr, strlen(ptr));
}
@ -7305,13 +7391,16 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!val || !ptr)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
return NULL;
}
if (yyjson_unlikely(len == 0)) { return val; }
if (yyjson_unlikely(len == 0)) {
return val;
}
if (yyjson_unlikely(*ptr != '/')) {
yyjson_ptr_set_err(SYNTAX, "no prefix '/'");
return NULL;
@ -7324,7 +7413,8 @@ extern "C" {
const char* ptr,
yyjson_mut_val* new_val
) {
if (yyjson_unlikely(!ptr)) return false;
if (yyjson_unlikely(!ptr))
return false;
return yyjson_mut_doc_ptr_addn(doc, ptr, strlen(ptr), new_val);
}
@ -7347,7 +7437,8 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!doc || !ptr || !new_val)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@ -7395,7 +7486,8 @@ extern "C" {
yyjson_mut_val* new_val,
yyjson_mut_doc* doc
) {
if (yyjson_unlikely(!ptr)) return false;
if (yyjson_unlikely(!ptr))
return false;
return yyjson_mut_ptr_addn(val, ptr, strlen(ptr), new_val, doc);
}
@ -7420,7 +7512,8 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!val || !ptr || !new_val || !doc)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@ -7444,7 +7537,8 @@ extern "C" {
const char* ptr,
yyjson_mut_val* new_val
) {
if (yyjson_unlikely(!ptr)) return false;
if (yyjson_unlikely(!ptr))
return false;
return yyjson_mut_doc_ptr_setn(doc, ptr, strlen(ptr), new_val);
}
@ -7467,14 +7561,16 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!doc || !ptr)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
return false;
}
if (yyjson_unlikely(len == 0)) {
if (ctx) ctx->old = doc->root;
if (ctx)
ctx->old = doc->root;
doc->root = new_val;
return true;
}
@ -7518,7 +7614,8 @@ extern "C" {
yyjson_mut_val* new_val,
yyjson_mut_doc* doc
) {
if (yyjson_unlikely(!ptr)) return false;
if (yyjson_unlikely(!ptr))
return false;
return yyjson_mut_ptr_setn(val, ptr, strlen(ptr), new_val, doc);
}
@ -7543,7 +7640,8 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!val || !ptr || !doc)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@ -7570,7 +7668,8 @@ extern "C" {
const char* ptr,
yyjson_mut_val* new_val
) {
if (!ptr) return NULL;
if (!ptr)
return NULL;
return yyjson_mut_doc_ptr_replacen(doc, ptr, strlen(ptr), new_val);
}
@ -7592,7 +7691,8 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!doc || !ptr || !new_val)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@ -7604,7 +7704,8 @@ extern "C" {
yyjson_ptr_set_err(RESOLVE, "JSON pointer cannot be resolved");
return NULL;
}
if (ctx) ctx->old = root;
if (ctx)
ctx->old = root;
doc->root = new_val;
return root;
}
@ -7626,7 +7727,8 @@ extern "C" {
const char* ptr,
yyjson_mut_val* new_val
) {
if (!ptr) return NULL;
if (!ptr)
return NULL;
return yyjson_mut_ptr_replacen(val, ptr, strlen(ptr), new_val);
}
@ -7648,7 +7750,8 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!val || !ptr || !new_val)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@ -7667,7 +7770,8 @@ extern "C" {
yyjson_api_inline yyjson_mut_val*
yyjson_mut_doc_ptr_remove(yyjson_mut_doc* doc, const char* ptr) {
if (!ptr) return NULL;
if (!ptr)
return NULL;
return yyjson_mut_doc_ptr_removen(doc, ptr, strlen(ptr));
}
@ -7684,7 +7788,8 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!doc || !ptr)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@ -7696,7 +7801,8 @@ extern "C" {
}
if (yyjson_unlikely(len == 0)) {
yyjson_mut_val* root = doc->root;
if (ctx) ctx->old = root;
if (ctx)
ctx->old = root;
doc->root = NULL;
return root;
}
@ -7709,7 +7815,8 @@ extern "C" {
yyjson_api_inline yyjson_mut_val*
yyjson_mut_ptr_remove(yyjson_mut_val* val, const char* ptr) {
if (!ptr) return NULL;
if (!ptr)
return NULL;
return yyjson_mut_ptr_removen(val, ptr, strlen(ptr));
}
@ -7726,7 +7833,8 @@ extern "C" {
yyjson_ptr_err* err
) {
yyjson_ptr_set_err(NONE, NULL);
if (ctx) memset(ctx, 0, sizeof(*ctx));
if (ctx)
memset(ctx, 0, sizeof(*ctx));
if (yyjson_unlikely(!val || !ptr)) {
yyjson_ptr_set_err(PARAMETER, "input parameter is NULL");
@ -7749,11 +7857,13 @@ extern "C" {
yyjson_mut_val* val
) {
yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
if (!ctx || !ctx->ctn || !val) return false;
if (!ctx || !ctx->ctn || !val)
return false;
ctn = ctx->ctn;
if (yyjson_mut_is_obj(ctn)) {
if (!key) return false;
if (!key)
return false;
key->next = val;
pre_key = ctx->pre;
if (unsafe_yyjson_get_len(ctn) == 0) {
@ -7772,7 +7882,8 @@ extern "C" {
cur_val = cur_key->next;
val->next = cur_val->next;
cur_val->next = key;
if (ctn->uni.ptr == cur_key) ctn->uni.ptr = key;
if (ctn->uni.ptr == cur_key)
ctn->uni.ptr = key;
ctx->pre = cur_key;
}
} else {
@ -7791,7 +7902,8 @@ extern "C" {
cur_val = pre_val->next;
val->next = cur_val->next;
cur_val->next = val;
if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
if (ctn->uni.ptr == cur_val)
ctn->uni.ptr = val;
ctx->pre = cur_val;
}
}
@ -7802,7 +7914,8 @@ extern "C" {
yyjson_api_inline bool
yyjson_ptr_ctx_replace(yyjson_ptr_ctx* ctx, yyjson_mut_val* val) {
yyjson_mut_val *ctn, *pre_key, *cur_key, *pre_val, *cur_val;
if (!ctx || !ctx->ctn || !ctx->pre || !val) return false;
if (!ctx || !ctx->ctn || !ctx->pre || !val)
return false;
ctn = ctx->ctn;
if (yyjson_mut_is_obj(ctn)) {
pre_key = ctx->pre;
@ -7820,7 +7933,8 @@ extern "C" {
if (pre_val != cur_val) {
val->next = cur_val->next;
pre_val->next = val;
if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
if (ctn->uni.ptr == cur_val)
ctn->uni.ptr = val;
} else {
val->next = val;
ctn->uni.ptr = val;
@ -7834,7 +7948,8 @@ extern "C" {
yyjson_api_inline bool yyjson_ptr_ctx_remove(yyjson_ptr_ctx* ctx) {
yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
size_t len;
if (!ctx || !ctx->ctn || !ctx->pre) return false;
if (!ctx || !ctx->ctn || !ctx->pre)
return false;
ctn = ctx->ctn;
if (yyjson_mut_is_obj(ctn)) {
pre_key = ctx->pre;
@ -7843,7 +7958,8 @@ extern "C" {
cur_val = cur_key->next;
/* remove current key-value */
pre_val->next = cur_val->next;
if (ctn->uni.ptr == cur_key) ctn->uni.ptr = pre_key;
if (ctn->uni.ptr == cur_key)
ctn->uni.ptr = pre_key;
ctx->pre = NULL;
ctx->old = cur_val;
} else {
@ -7851,12 +7967,14 @@ extern "C" {
cur_val = pre_val->next;
/* remove current key-value */
pre_val->next = cur_val->next;
if (ctn->uni.ptr == cur_val) ctn->uni.ptr = pre_val;
if (ctn->uni.ptr == cur_val)
ctn->uni.ptr = pre_val;
ctx->pre = NULL;
ctx->old = cur_val;
}
len = unsafe_yyjson_get_len(ctn) - 1;
if (len == 0) ctn->uni.ptr = NULL;
if (len == 0)
ctn->uni.ptr = NULL;
unsafe_yyjson_set_len(ctn, len);
return true;
}

63
src/main.cpp
View file

@ -13,10 +13,9 @@ struct BytesToGiB {
template <>
struct fmt::formatter<BytesToGiB> : formatter<double> {
template <typename FormatContext>
typename FormatContext::iterator
format(const BytesToGiB BTG, FormatContext& ctx) {
typename FormatContext::iterator out = formatter<double>::format(
template <typename FmtCtx>
fn format(const BytesToGiB BTG, FmtCtx& ctx) -> typename FmtCtx::iterator {
typename FmtCtx::iterator out = formatter<double>::format(
static_cast<double>(BTG.value) / pow(1024, 3), ctx
);
*out++ = 'G';
@ -26,53 +25,35 @@ struct fmt::formatter<BytesToGiB> : formatter<double> {
}
};
enum DateNum { Ones, Twos, Threes, Default };
DateNum ParseDate(string const& input) {
if (input == "1" || input == "21" || input == "31") return Ones;
if (input == "2" || input == "22") return Twos;
if (input == "3" || input == "23") return Threes;
return Default;
}
int main() {
const Config& config = Config::getInstance();
if (config.getNowPlaying().getEnabled()) fmt::println("{}", GetNowPlaying());
fmt::println("Hello {}!", config.getGeneral().getName());
const u64 memInfo = GetMemInfo();
fmt::println("{:.2f}", BytesToGiB {memInfo});
fn GetDate() -> string {
const std::tm localTime = fmt::localtime(time(nullptr));
string date = fmt::format("{:%e}", localTime);
auto start = date.begin();
while (start != date.end() && std::isspace(*start)) ++start;
date.erase(date.begin(), start);
if (!date.empty() && std::isspace(date.front()))
date.erase(date.begin());
switch (ParseDate(date)) {
case Ones:
if (date == "1" || date == "21" || date == "31")
date += "st";
break;
case Twos:
else if (date == "2" || date == "22")
date += "nd";
break;
case Threes:
else if (date == "3" || date == "23")
date += "rd";
break;
case Default:
else
date += "th";
break;
}
fmt::println("{:%B} {}, {:%-I:%0M %p}", localTime, date, localTime);
return fmt::format("{:%B} {}, {:%-I:%0M %p}", localTime, date, localTime);
}
fn main() -> int {
const Config& config = Config::getInstance();
if (config.getNowPlaying().getEnabled())
fmt::println("{}", GetNowPlaying());
fmt::println("Hello {}!", config.getGeneral().getName());
fmt::println("Installed RAM: {:.2f}", BytesToGiB {GetMemInfo()});
fmt::println("Today is: {}", GetDate());
Weather::WeatherOutput json = config.getWeather().getWeatherInfo();

12
src/os/linux.cpp
View file

@ -93,13 +93,15 @@ std::vector<std::string> GetMprisPlayers(sdbus::IConnection& connection) {
std::vector<std::string> mprisPlayers;
for (const std::basic_string<char>& name : names)
if (name.contains(mprisInterfaceName)) mprisPlayers.push_back(name);
if (name.contains(mprisInterfaceName))
mprisPlayers.push_back(name);
return mprisPlayers;
}
std::string GetActivePlayer(const std::vector<std::string>& mprisPlayers) {
if (!mprisPlayers.empty()) return mprisPlayers.front();
if (!mprisPlayers.empty())
return mprisPlayers.front();
return "";
}
@ -114,11 +116,13 @@ std::string GetNowPlaying() {
std::vector<std::string> mprisPlayers = GetMprisPlayers(*connection);
if (mprisPlayers.empty()) return "";
if (mprisPlayers.empty())
return "";
std::string activePlayer = GetActivePlayer(mprisPlayers);
if (activePlayer.empty()) return "";
if (activePlayer.empty())
return "";
std::unique_ptr<sdbus::IProxy> playerProxy =
sdbus::createProxy(*connection, activePlayer, playerObjectPath);