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

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
Download patch file Download diff file Expand all files Collapse all files

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;
}