From 8ff653c4a49b89e813c61f62ae7b81e1f3227b56 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sat, 25 Oct 2025 20:54:42 +0200 Subject: [PATCH 01/18] Better error handling in the writer for the JSON format --- include/rfl/json/Writer.hpp | 40 +++++++++++++++++++----------- src/rfl/json/Writer.cpp | 49 +++++++++++++++++++++++++++---------- 2 files changed, 62 insertions(+), 27 deletions(-) diff --git a/include/rfl/json/Writer.hpp b/include/rfl/json/Writer.hpp index 4a938771d..7337002f6 100644 --- a/include/rfl/json/Writer.hpp +++ b/include/rfl/json/Writer.hpp @@ -11,7 +11,7 @@ #include #include -//#include "../Result.hpp" +// #include "../Result.hpp" #include "../always_false.hpp" #include "../common.hpp" @@ -60,41 +60,48 @@ class RFL_API Writer { } OutputArrayType add_array_to_array(const size_t, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t, + OutputObjectType* _parent) const; template OutputVarType add_value_to_array(const T& _var, - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { const auto val = from_basic_type(_var); - yyjson_mut_arr_add_val(_parent->val_, val.val_); + const bool ok = yyjson_mut_arr_add_val(_parent->val_, val.val_); + if (!ok) { + throw std::runtime_error("Could not add value to array."); + } return OutputVarType(val); } template OutputVarType add_value_to_object(const std::string_view& _name, const T& _var, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { const auto val = from_basic_type(_var); - yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()), - val.val_); + const bool ok = yyjson_mut_obj_add( + _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), val.val_); + if (!ok) { + throw std::runtime_error("Could not add field '" + std::string(_name) + + "' to object."); + } return OutputVarType(val); } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; void end_array(OutputArrayType*) const noexcept; @@ -105,14 +112,19 @@ class RFL_API Writer { OutputVarType from_basic_type(const T& _var) const noexcept { if constexpr (std::is_same, std::string>()) { return OutputVarType(yyjson_mut_strcpy(doc_, _var.c_str())); + } else if constexpr (std::is_same, bool>()) { return OutputVarType(yyjson_mut_bool(doc_, _var)); + } else if constexpr (std::is_floating_point>()) { return OutputVarType(yyjson_mut_real(doc_, static_cast(_var))); + } else if constexpr (std::is_unsigned>()) { return OutputVarType(yyjson_mut_uint(doc_, static_cast(_var))); + } else if constexpr (std::is_integral>()) { return OutputVarType(yyjson_mut_int(doc_, static_cast(_var))); + } else { static_assert(rfl::always_false_v, "Unsupported type."); } diff --git a/src/rfl/json/Writer.cpp b/src/rfl/json/Writer.cpp index 49244a0bd..2a1d26fe0 100644 --- a/src/rfl/json/Writer.cpp +++ b/src/rfl/json/Writer.cpp @@ -49,47 +49,70 @@ Writer::OutputVarType Writer::null_as_root() const noexcept { } Writer::OutputArrayType Writer::add_array_to_array( - const size_t, OutputArrayType* _parent) const noexcept { + const size_t, OutputArrayType* _parent) const { const auto arr = yyjson_mut_arr(doc_); - yyjson_mut_arr_add_val(_parent->val_, arr); + const bool ok = yyjson_mut_arr_add_val(_parent->val_, arr); + if (!ok) { + throw std::runtime_error("Adding an array to an array failed."); + } return OutputArrayType(arr); } Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { const auto arr = yyjson_mut_arr(doc_); - yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()), arr); + const bool ok = yyjson_mut_obj_add( + _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), arr); + if (!ok) { + throw std::runtime_error("Could not add field '" + std::string(_name) + + "' to object."); + } return OutputArrayType(arr); } Writer::OutputObjectType Writer::add_object_to_array( - const size_t, OutputArrayType* _parent) const noexcept { + const size_t, OutputArrayType* _parent) const { const auto obj = yyjson_mut_obj(doc_); - yyjson_mut_arr_add_val(_parent->val_, obj); + const bool ok = yyjson_mut_arr_add_val(_parent->val_, obj); + if (!ok) { + throw std::runtime_error("Adding an object to an array failed."); + } return OutputObjectType(obj); } Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { const auto obj = yyjson_mut_obj(doc_); - yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()), obj); + const auto ok = yyjson_mut_obj_add( + _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), obj); + if (!ok) { + throw std::runtime_error("Could not add field '" + std::string(_name) + + "' to object."); + } return OutputObjectType(obj); } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { const auto null = yyjson_mut_null(doc_); - yyjson_mut_arr_add_val(_parent->val_, null); + const bool ok = yyjson_mut_arr_add_val(_parent->val_, null); + if (!ok) { + throw std::runtime_error("Adding null to an array failed."); + } return OutputVarType(null); } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* _parent) const noexcept { + const std::string_view& _name, OutputObjectType* _parent) const { const auto null = yyjson_mut_null(doc_); - yyjson_mut_obj_add(_parent->val_, yyjson_mut_strcpy(doc_, _name.data()), - null); + const bool ok = yyjson_mut_obj_add( + _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), null); + if (!ok) { + throw std::runtime_error("Could not add field '" + std::string(_name) + + "' to object."); + } return OutputVarType(null); } From a4034a965100a40042538147e7a89e8094619b78 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sat, 25 Oct 2025 21:37:54 +0200 Subject: [PATCH 02/18] Added exceptions for msgpack --- include/rfl/msgpack/Reader.hpp | 10 +-- include/rfl/msgpack/Writer.hpp | 90 +++++++++++++------- include/rfl/msgpack/write.hpp | 4 +- include/rfl/parsing/Parser_tagged_union.hpp | 7 +- src/rfl/msgpack/Writer.cpp | 92 +++++++++++++++------ 5 files changed, 133 insertions(+), 70 deletions(-) diff --git a/include/rfl/msgpack/Reader.hpp b/include/rfl/msgpack/Reader.hpp index c42c09f42..fd87510f8 100644 --- a/include/rfl/msgpack/Reader.hpp +++ b/include/rfl/msgpack/Reader.hpp @@ -9,11 +9,11 @@ #include #include -#include "../Bytestring.hpp" #include "../Result.hpp" -#include "../Vectorstring.hpp" #include "../always_false.hpp" +#include "../concepts.hpp" #include "../internal/ptr_cast.hpp" +#include "rfl/concepts.hpp" namespace rfl { namespace msgpack { @@ -66,10 +66,8 @@ struct Reader { const auto str = _var.via.str; return std::string(str.ptr, str.size); - } else if constexpr (std::is_same, - rfl::Bytestring>() || - std::is_same, - rfl::Vectorstring>()) { + } else if constexpr (concepts::MutableContiguousByteContainer< + std::remove_cvref_t>) { using VectorType = std::remove_cvref_t; using ValueType = typename VectorType::value_type; if (type != MSGPACK_OBJECT_BIN) { diff --git a/include/rfl/msgpack/Writer.hpp b/include/rfl/msgpack/Writer.hpp index dbf980ec0..fa7a02253 100644 --- a/include/rfl/msgpack/Writer.hpp +++ b/include/rfl/msgpack/Writer.hpp @@ -5,14 +5,14 @@ #include #include +#include #include #include #include -#include "../Bytestring.hpp" -#include "../Vectorstring.hpp" #include "../always_false.hpp" #include "../common.hpp" +#include "../concepts.hpp" namespace rfl::msgpack { @@ -32,80 +32,106 @@ class RFL_API Writer { ~Writer(); - OutputArrayType array_as_root(const size_t _size) const noexcept; + OutputArrayType array_as_root(const size_t _size) const; - OutputObjectType object_as_root(const size_t _size) const noexcept; + OutputObjectType object_as_root(const size_t _size) const; - OutputVarType null_as_root() const noexcept; + OutputVarType null_as_root() const; template - OutputVarType value_as_root(const T& _var) const noexcept { + OutputVarType value_as_root(const T& _var) const { return new_value(_var); } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t _size, + OutputObjectType* _parent) const; template - OutputVarType add_value_to_array( - const T& _var, OutputArrayType* /*_parent*/) const noexcept { + OutputVarType add_value_to_array(const T& _var, OutputArrayType*) const { return new_value(_var); } template - OutputVarType add_value_to_object( - const std::string_view& _name, const T& _var, - OutputObjectType* /*_parent*/) const noexcept { + OutputVarType add_value_to_object(const std::string_view& _name, + const T& _var, OutputObjectType*) const { msgpack_pack_str(pk_, _name.size()); msgpack_pack_str_body(pk_, _name.data(), _name.size()); return new_value(_var); } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; void end_array(OutputArrayType* _arr) const noexcept; void end_object(OutputObjectType* _obj) const noexcept; private: - OutputArrayType new_array(const size_t _size) const noexcept; + OutputArrayType new_array(const size_t _size) const; - OutputObjectType new_object(const size_t _size) const noexcept; + OutputObjectType new_object(const size_t _size) const; template - OutputVarType new_value(const T& _var) const noexcept { + OutputVarType new_value(const T& _var) const { using Type = std::remove_cvref_t; if constexpr (std::is_same()) { - msgpack_pack_str(pk_, _var.size()); - msgpack_pack_str_body(pk_, _var.c_str(), _var.size()); - } else if constexpr (std::is_same() || - std::is_same()) { - msgpack_pack_bin(pk_, _var.size()); - msgpack_pack_bin_body(pk_, _var.data(), _var.size()); + auto err = msgpack_pack_str(pk_, _var.size()); + if (err) { + throw std::runtime_error("Could not pack string."); + } + err = msgpack_pack_str_body(pk_, _var.c_str(), _var.size()); + if (err) { + throw std::runtime_error("Could not pack string body."); + } + + } else if constexpr (concepts::MutableContiguousByteContainer) { + auto err = msgpack_pack_bin(pk_, _var.size()); + if (err) { + throw std::runtime_error("Could not pack binary string."); + } + err = msgpack_pack_bin_body(pk_, _var.data(), _var.size()); + if (err) { + throw std::runtime_error("Could not pack binary string."); + } + } else if constexpr (std::is_same()) { if (_var) { - msgpack_pack_true(pk_); + const auto err = msgpack_pack_true(pk_); + if (err) { + throw std::runtime_error("Could not pack boolean."); + } } else { - msgpack_pack_false(pk_); + const auto err = msgpack_pack_false(pk_); + if (err) { + throw std::runtime_error("Could not pack boolean."); + } } + } else if constexpr (std::is_floating_point()) { - msgpack_pack_double(pk_, static_cast(_var)); + const auto err = msgpack_pack_double(pk_, static_cast(_var)); + if (err) { + throw std::runtime_error("Could not pack double."); + } + } else if constexpr (std::is_integral()) { - msgpack_pack_int64(pk_, static_cast(_var)); + const auto err = msgpack_pack_int64(pk_, static_cast(_var)); + if (err) { + throw std::runtime_error("Could not pack int."); + } + } else { static_assert(rfl::always_false_v, "Unsupported type."); } diff --git a/include/rfl/msgpack/write.hpp b/include/rfl/msgpack/write.hpp index 5a9df5f6a..874ca0588 100644 --- a/include/rfl/msgpack/write.hpp +++ b/include/rfl/msgpack/write.hpp @@ -13,7 +13,7 @@ namespace rfl::msgpack { /// Returns msgpack bytes. template -std::vector write(const auto& _obj) noexcept { +std::vector write(const auto& _obj) { using T = std::remove_cvref_t; using ParentType = parsing::Parent; msgpack_sbuffer sbuf; @@ -29,7 +29,7 @@ std::vector write(const auto& _obj) noexcept { /// Writes a MSGPACK into an ostream. template -std::ostream& write(const auto& _obj, std::ostream& _stream) noexcept { +std::ostream& write(const auto& _obj, std::ostream& _stream) { auto buffer = write(_obj); _stream.write(buffer.data(), buffer.size()); return _stream; diff --git a/include/rfl/parsing/Parser_tagged_union.hpp b/include/rfl/parsing/Parser_tagged_union.hpp index f752762af..8821dc5c4 100644 --- a/include/rfl/parsing/Parser_tagged_union.hpp +++ b/include/rfl/parsing/Parser_tagged_union.hpp @@ -127,7 +127,7 @@ struct Parser, const std::string& _disc_value, const InputVarType& _var, ResultType* _result, - bool* _match_found) noexcept { + bool* _match_found) { using AlternativeType = std::remove_cvref_t< std::variant_alternative_t<_i, std::variant>>; @@ -206,8 +206,7 @@ struct Parser, /// Writes a wrapped version of the original object, which contains the tag. template - static void write_wrapped(const W& _w, const T& _val, - const P& _parent) noexcept { + static void write_wrapped(const W& _w, const T& _val, const P& _parent) { const auto wrapped = wrap_if_necessary(_val); Parser, ProcessorsType>::write( _w, wrapped, _parent); @@ -216,7 +215,7 @@ struct Parser, /// Generates a wrapped version of the original object, which contains the /// tag, if the object doesn't already contain the wrap. template - static auto wrap_if_necessary(const T& _val) noexcept { + static auto wrap_if_necessary(const T& _val) { if constexpr (named_tuple_t::Names::template contains< _discriminator>()) { return _val; diff --git a/src/rfl/msgpack/Writer.cpp b/src/rfl/msgpack/Writer.cpp index adac73839..fa1e39d52 100644 --- a/src/rfl/msgpack/Writer.cpp +++ b/src/rfl/msgpack/Writer.cpp @@ -1,63 +1,97 @@ #include "rfl/msgpack/Writer.hpp" +#include + namespace rfl::msgpack { Writer::Writer(msgpack_packer* _pk) : pk_(_pk) {} Writer::~Writer() = default; -Writer::OutputArrayType Writer::array_as_root( - const size_t _size) const noexcept { +Writer::OutputArrayType Writer::array_as_root(const size_t _size) const { return new_array(_size); } -Writer::OutputObjectType Writer::object_as_root( - const size_t _size) const noexcept { +Writer::OutputObjectType Writer::object_as_root(const size_t _size) const { return new_object(_size); } -Writer::OutputVarType Writer::null_as_root() const noexcept { - msgpack_pack_nil(pk_); +Writer::OutputVarType Writer::null_as_root() const { + const auto err = msgpack_pack_nil(pk_); + if (err) { + throw std::runtime_error("Could not pack null as root."); + } return OutputVarType{}; } Writer::OutputArrayType Writer::add_array_to_array( - const size_t _size, OutputArrayType* /*_parent*/) const noexcept { + const size_t _size, OutputArrayType* /*_parent*/) const { return new_array(_size); } Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t _size, - OutputObjectType* /*_parent*/) const noexcept { - msgpack_pack_str(pk_, _name.size()); - msgpack_pack_str_body(pk_, _name.data(), _name.size()); + OutputObjectType* /*_parent*/) const { + auto err = msgpack_pack_str(pk_, _name.size()); + if (err) { + throw std::runtime_error("Could not pack field name: '" + + std::string(_name) + "'"); + } + err = msgpack_pack_str_body(pk_, _name.data(), _name.size()); + if (err) { + throw std::runtime_error("Could not pack field name body: '" + + std::string(_name) + "'"); + } return new_array(_size); } -Writer::OutputObjectType Writer::add_object_to_array( - const size_t _size, OutputArrayType* /*_parent*/) const noexcept { +Writer::OutputObjectType Writer::add_object_to_array(const size_t _size, + OutputArrayType*) const { return new_object(_size); } Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t _size, - OutputObjectType* /*_parent*/) const noexcept { - msgpack_pack_str(pk_, _name.size()); - msgpack_pack_str_body(pk_, _name.data(), _name.size()); + OutputObjectType*) const { + auto err = msgpack_pack_str(pk_, _name.size()); + if (err) { + throw std::runtime_error("Could not pack field name: '" + + std::string(_name) + "'"); + } + err = msgpack_pack_str_body(pk_, _name.data(), _name.size()); + if (err) { + throw std::runtime_error("Could not pack field name body: '" + + std::string(_name) + "'"); + } return new_object(_size); } -Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* /*_parent*/) const noexcept { - msgpack_pack_nil(pk_); +Writer::OutputVarType Writer::add_null_to_array(OutputArrayType*) const { + const auto err = msgpack_pack_nil(pk_); + if (err) { + throw std::runtime_error("Could not add nil to array."); + } return OutputVarType{}; } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept { - msgpack_pack_str(pk_, _name.size()); - msgpack_pack_str_body(pk_, _name.data(), _name.size()); - msgpack_pack_nil(pk_); + const std::string_view& _name, OutputObjectType* /*_parent*/) const { + auto err = msgpack_pack_str(pk_, _name.size()); + if (err) { + throw std::runtime_error("Could not pack field name: '" + + std::string(_name) + "'"); + } + err = msgpack_pack_str_body(pk_, _name.data(), _name.size()); + if (err) { + throw std::runtime_error("Could not pack field name body: '" + + std::string(_name) + "'"); + } + err = msgpack_pack_nil(pk_); + if (err) { + throw std::runtime_error( + "Could not pack null value for the following field: '" + + std::string(_name) + "'"); + } return OutputVarType{}; } @@ -65,13 +99,19 @@ void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {} void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {} -Writer::OutputArrayType Writer::new_array(const size_t _size) const noexcept { - msgpack_pack_array(pk_, _size); +Writer::OutputArrayType Writer::new_array(const size_t _size) const { + const auto err = msgpack_pack_array(pk_, _size); + if (err) { + throw std::runtime_error("Could not pack array."); + } return OutputArrayType{}; } -Writer::OutputObjectType Writer::new_object(const size_t _size) const noexcept { - msgpack_pack_map(pk_, _size); +Writer::OutputObjectType Writer::new_object(const size_t _size) const { + const auto err = msgpack_pack_map(pk_, _size); + if (err) { + throw std::runtime_error("Could not pack array."); + } return OutputObjectType{}; } From 5c51824995929dd54bbb46c6c1ebc3cb4d12f9fb Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sat, 25 Oct 2025 21:39:53 +0200 Subject: [PATCH 03/18] Removed non-relative include --- include/rfl/msgpack/Reader.hpp | 1 - 1 file changed, 1 deletion(-) diff --git a/include/rfl/msgpack/Reader.hpp b/include/rfl/msgpack/Reader.hpp index fd87510f8..1c4345c48 100644 --- a/include/rfl/msgpack/Reader.hpp +++ b/include/rfl/msgpack/Reader.hpp @@ -13,7 +13,6 @@ #include "../always_false.hpp" #include "../concepts.hpp" #include "../internal/ptr_cast.hpp" -#include "rfl/concepts.hpp" namespace rfl { namespace msgpack { From 2dec03b55c19a7c4e965dd3dc74787fbcf468e63 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sat, 25 Oct 2025 22:16:40 +0200 Subject: [PATCH 04/18] Added exceptions to BSON --- include/rfl/bson/Reader.hpp | 9 +-- include/rfl/bson/Writer.hpp | 148 ++++++++++++++++++++++++------------ include/rfl/bson/write.hpp | 6 +- src/rfl/bson/Writer.cpp | 88 +++++++++++++++------ 4 files changed, 169 insertions(+), 82 deletions(-) diff --git a/include/rfl/bson/Reader.hpp b/include/rfl/bson/Reader.hpp index 9cb714d66..e7d55f1c2 100644 --- a/include/rfl/bson/Reader.hpp +++ b/include/rfl/bson/Reader.hpp @@ -9,10 +9,9 @@ #include #include -#include "../Bytestring.hpp" #include "../Result.hpp" -#include "../Vectorstring.hpp" #include "../always_false.hpp" +#include "../concepts.hpp" #include "../internal/ptr_cast.hpp" namespace rfl { @@ -102,10 +101,8 @@ struct Reader { "Could not cast to string. The type must be UTF8 or symbol."); } - } else if constexpr (std::is_same, - rfl::Bytestring>() || - std::is_same, - rfl::Vectorstring>()) { + } else if constexpr (concepts::MutableContiguousByteContainer< + std::remove_cvref_t>) { using VectorType = std::remove_cvref_t; using ValueType = typename VectorType::value_type; if (btype != BSON_TYPE_BINARY) { diff --git a/include/rfl/bson/Writer.hpp b/include/rfl/bson/Writer.hpp index 5267b6be3..15ae39f65 100644 --- a/include/rfl/bson/Writer.hpp +++ b/include/rfl/bson/Writer.hpp @@ -11,13 +11,11 @@ #include #include "../Box.hpp" -#include "../Bytestring.hpp" #include "../Ref.hpp" -//#include "../Result.hpp" -#include "../Vectorstring.hpp" #include "../always_false.hpp" -#include "../internal/ptr_cast.hpp" #include "../common.hpp" +#include "../concepts.hpp" +#include "../internal/ptr_cast.hpp" namespace rfl { namespace bson { @@ -79,43 +77,65 @@ class RFL_API Writer { } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t _size, + OutputObjectType* _parent) const; template OutputVarType add_value_to_array(const T& _var, - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { if constexpr (std::is_same, std::string>()) { - bson_array_builder_append_utf8(_parent->val_, _var.c_str(), - static_cast(_var.size())); - } else if constexpr (std::is_same, - rfl::Bytestring>() || - std::is_same, - rfl::Vectorstring>()) { - bson_array_builder_append_binary( + const bool ok = bson_array_builder_append_utf8( + _parent->val_, _var.c_str(), static_cast(_var.size())); + if (!ok) { + throw std::runtime_error("Could not append utf-8 to array."); + } + + } else if constexpr (concepts::MutableContiguousByteContainer< + std::remove_cvref_t>) { + const bool ok = bson_array_builder_append_binary( _parent->val_, BSON_SUBTYPE_BINARY, internal::ptr_cast(_var.data()), static_cast(_var.size())); + if (!ok) { + throw std::runtime_error("Could not append binary to array."); + } + } else if constexpr (std::is_same, bool>()) { - bson_array_builder_append_bool(_parent->val_, _var); + const bool ok = bson_array_builder_append_bool(_parent->val_, _var); + if (!ok) { + throw std::runtime_error("Could not append bool to array."); + } + } else if constexpr (std::is_floating_point>()) { - bson_array_builder_append_double(_parent->val_, - static_cast(_var)); + const bool ok = bson_array_builder_append_double( + _parent->val_, static_cast(_var)); + if (!ok) { + throw std::runtime_error("Could not append float to array."); + } + } else if constexpr (std::is_integral>()) { - bson_array_builder_append_int64(_parent->val_, - static_cast(_var)); + const bool ok = bson_array_builder_append_int64( + _parent->val_, static_cast(_var)); + if (!ok) { + throw std::runtime_error("Could not append integer to array."); + } + } else if constexpr (std::is_same, bson_oid_t>()) { - bson_array_builder_append_oid(_parent->val_, &_var); + const bool ok = bson_array_builder_append_oid(_parent->val_, &_var); + if (!ok) { + throw std::runtime_error("Could not append OID to array."); + } + } else { static_assert(rfl::always_false_v, "Unsupported type."); } @@ -125,47 +145,75 @@ class RFL_API Writer { template OutputVarType add_value_to_object(const std::string_view& _name, const T& _var, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { if constexpr (std::is_same, std::string>()) { - bson_append_utf8(_parent->val_, _name.data(), - static_cast(_name.size()), _var.c_str(), - static_cast(_var.size())); - } else if constexpr (std::is_same, - rfl::Bytestring>() || - std::is_same, - rfl::Vectorstring>()) { - bson_append_binary(_parent->val_, _name.data(), - static_cast(_name.size()), BSON_SUBTYPE_BINARY, - internal::ptr_cast(_var.data()), - static_cast(_var.size())); + const bool ok = bson_append_utf8( + _parent->val_, _name.data(), static_cast(_name.size()), + _var.c_str(), static_cast(_var.size())); + if (!ok) { + throw std::runtime_error("Could not utf-8 field '" + + std::string(_name) + "' to object."); + } + + } else if constexpr (concepts::MutableContiguousByteContainer< + std::remove_cvref_t>) { + const bool ok = bson_append_binary( + _parent->val_, _name.data(), static_cast(_name.size()), + BSON_SUBTYPE_BINARY, internal::ptr_cast(_var.data()), + static_cast(_var.size())); + if (!ok) { + throw std::runtime_error("Could not binary field '" + + std::string(_name) + "' to object."); + } + } else if constexpr (std::is_same, bool>()) { - bson_append_bool(_parent->val_, _name.data(), - static_cast(_name.size()), _var); + const bool ok = bson_append_bool(_parent->val_, _name.data(), + static_cast(_name.size()), _var); + if (!ok) { + throw std::runtime_error("Could not boolean field '" + + std::string(_name) + "' to object."); + } + } else if constexpr (std::is_floating_point>()) { - bson_append_double(_parent->val_, _name.data(), - static_cast(_name.size()), - static_cast(_var)); + const bool ok = bson_append_double(_parent->val_, _name.data(), + static_cast(_name.size()), + static_cast(_var)); + if (!ok) { + throw std::runtime_error("Could not floating point field '" + + std::string(_name) + "' to object."); + } + } else if constexpr (std::is_integral>()) { - bson_append_int64(_parent->val_, _name.data(), - static_cast(_name.size()), - static_cast(_var)); + const bool ok = bson_append_int64(_parent->val_, _name.data(), + static_cast(_name.size()), + static_cast(_var)); + if (!ok) { + throw std::runtime_error("Could not int field '" + std::string(_name) + + "' to object."); + } + } else if constexpr (std::is_same, bson_oid_t>()) { - bson_append_oid(_parent->val_, _name.data(), - static_cast(_name.size()), &_var); + const bool ok = bson_append_oid(_parent->val_, _name.data(), + static_cast(_name.size()), &_var); + if (!ok) { + throw std::runtime_error("Could not oid field '" + std::string(_name) + + "' to object."); + } + } else { static_assert(rfl::always_false_v, "Unsupported type."); } return OutputVarType{}; } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; - void end_array(OutputArrayType* _arr) const noexcept; + void end_array(OutputArrayType* _arr) const; - void end_object(OutputObjectType* _obj) const noexcept; + void end_object(OutputObjectType* _obj) const; private: /// Pointer to the main document. In BSON, documents are what are usually diff --git a/include/rfl/bson/write.hpp b/include/rfl/bson/write.hpp index 845a4d134..ec3d345db 100644 --- a/include/rfl/bson/write.hpp +++ b/include/rfl/bson/write.hpp @@ -17,7 +17,7 @@ namespace bson { /// Returns BSON bytes. Careful: It is the responsibility of the caller to call /// bson_free on the returned pointer. template -std::pair to_buffer(const auto& _obj) noexcept { +std::pair to_buffer(const auto& _obj) { using T = std::remove_cvref_t; using ParentType = parsing::Parent; bson_t* doc = nullptr; @@ -41,7 +41,7 @@ std::pair to_buffer(const auto& _obj) noexcept { /// Returns BSON bytes. template -std::vector write(const auto& _obj) noexcept { +std::vector write(const auto& _obj) { auto [buf, len] = to_buffer(_obj); const auto result = std::vector(internal::ptr_cast(buf), internal::ptr_cast(buf) + len); @@ -51,7 +51,7 @@ std::vector write(const auto& _obj) noexcept { /// Writes a BSON into an ostream. template -std::ostream& write(const auto& _obj, std::ostream& _stream) noexcept { +std::ostream& write(const auto& _obj, std::ostream& _stream) { auto [buf, len] = to_buffer(_obj); _stream.write(internal::ptr_cast(buf), len); bson_free(buf); diff --git a/src/rfl/bson/Writer.cpp b/src/rfl/bson/Writer.cpp index adf124c88..d20213260 100644 --- a/src/rfl/bson/Writer.cpp +++ b/src/rfl/bson/Writer.cpp @@ -23,60 +23,93 @@ Writer::OutputVarType Writer::null_as_root() const noexcept { } Writer::OutputArrayType Writer::add_array_to_array( - const size_t /*_size*/, OutputArrayType* _parent) const noexcept { + const size_t /*_size*/, OutputArrayType* _parent) const { bson_array_builder_t* val; - bson_array_builder_append_array_builder_begin(_parent->val_, &val); + const bool ok = + bson_array_builder_append_array_builder_begin(_parent->val_, &val); + if (!ok) { + throw std::runtime_error("Could not array to array."); + } return OutputArrayType(val, IsArray{_parent->val_}); } Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { bson_array_builder_t* val; - bson_append_array_builder_begin(_parent->val_, _name.data(), - static_cast(_name.size()), &val); + const bool ok = bson_append_array_builder_begin( + _parent->val_, _name.data(), static_cast(_name.size()), &val); + if (!ok) { + throw std::runtime_error("Could not array to array."); + } return OutputArrayType(val, IsObject{_parent->val_}); } Writer::OutputObjectType Writer::add_object_to_array( - const size_t /*_size*/, OutputArrayType* _parent) const noexcept { + const size_t /*_size*/, OutputArrayType* _parent) const { subdocs_->emplace_back(rfl::Box()); - bson_array_builder_append_document_begin(_parent->val_, - &(subdocs_->back()->val_)); + const bool ok = bson_array_builder_append_document_begin( + _parent->val_, &(subdocs_->back()->val_)); + if (!ok) { + throw std::runtime_error("Could not object to array."); + } return OutputObjectType(&subdocs_->back()->val_, IsArray{_parent->val_}); } Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { subdocs_->emplace_back(rfl::Box()); - bson_append_document_begin(_parent->val_, _name.data(), - static_cast(_name.size()), - &(subdocs_->back()->val_)); + const bool ok = bson_append_document_begin(_parent->val_, _name.data(), + static_cast(_name.size()), + &(subdocs_->back()->val_)); + if (!ok) { + throw std::runtime_error("Could not add object to object."); + } return OutputObjectType(&subdocs_->back()->val_, IsObject{_parent->val_}); } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* _parent) const noexcept { - bson_array_builder_append_null(_parent->val_); + OutputArrayType* _parent) const { + const bool ok = bson_array_builder_append_null(_parent->val_); + if (!ok) { + throw std::runtime_error("Could not add null to array."); + } return OutputVarType{}; } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* _parent) const noexcept { - bson_append_null(_parent->val_, _name.data(), static_cast(_name.size())); + const std::string_view& _name, OutputObjectType* _parent) const { + const bool ok = bson_append_null(_parent->val_, _name.data(), + static_cast(_name.size())); + if (!ok) { + throw std::runtime_error("Could not add null to object."); + } return OutputVarType{}; } -void Writer::end_array(OutputArrayType* _arr) const noexcept { +void Writer::end_array(OutputArrayType* _arr) const { const auto handle = [&](const auto _parent) { using Type = std::remove_cvref_t; if constexpr (std::is_same()) { - bson_array_builder_append_array_builder_end(_parent.ptr_, _arr->val_); + const bool ok = + bson_array_builder_append_array_builder_end(_parent.ptr_, _arr->val_); + if (!ok) { + throw std::runtime_error("Could not end array."); + } + } else if constexpr (std::is_same()) { - bson_append_array_builder_end(_parent.ptr_, _arr->val_); + const bool ok = bson_append_array_builder_end(_parent.ptr_, _arr->val_); + if (!ok) { + throw std::runtime_error("Could not end array."); + } + } else if constexpr (std::is_same()) { - bson_array_builder_build(_arr->val_, doc_); + const bool ok = bson_array_builder_build(_arr->val_, doc_); + if (!ok) { + throw std::runtime_error("Could not end array."); + } + } else { static_assert(rfl::always_false_v, "Unsupported type."); } @@ -84,13 +117,22 @@ void Writer::end_array(OutputArrayType* _arr) const noexcept { std::visit(handle, _arr->parent_); } -void Writer::end_object(OutputObjectType* _obj) const noexcept { +void Writer::end_object(OutputObjectType* _obj) const { const auto handle = [&](const auto _parent) { using Type = std::remove_cvref_t; if constexpr (std::is_same()) { - bson_array_builder_append_document_end(_parent.ptr_, _obj->val_); + const bool ok = + bson_array_builder_append_document_end(_parent.ptr_, _obj->val_); + if (!ok) { + throw std::runtime_error("Could not end object."); + } + } else if constexpr (std::is_same()) { - bson_append_document_end(_parent.ptr_, _obj->val_); + const bool ok = bson_append_document_end(_parent.ptr_, _obj->val_); + if (!ok) { + throw std::runtime_error("Could not end object."); + } + } else if constexpr (std::is_same()) { } else { static_assert(rfl::always_false_v, "Unsupported type."); From f4f1c98c95d0ba0667ab20e6d6a15a61e39a1f29 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 10:39:54 +0100 Subject: [PATCH 05/18] Make sure we properly deference everything for Avro and BSON --- include/rfl/avro/write.hpp | 45 ++++++++++++++++++++++++-------------- include/rfl/bson/write.hpp | 41 ++++++++++++++++++++++++---------- 2 files changed, 57 insertions(+), 29 deletions(-) diff --git a/include/rfl/avro/write.hpp b/include/rfl/avro/write.hpp index 001f30590..90bea3cf1 100644 --- a/include/rfl/avro/write.hpp +++ b/include/rfl/avro/write.hpp @@ -8,7 +8,6 @@ #include "../parsing/Parent.hpp" #include "Parser.hpp" -//#include "Schema.hpp" #include "Writer.hpp" #include "to_schema.hpp" @@ -26,25 +25,37 @@ std::vector write(const auto& _obj, const auto& _schema) { int result = avro_generic_value_new(_schema.iface(), &root); if (result != 0) { avro_value_decref(&root); - throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): " + avro_strerror()); + throw std::runtime_error(std::string(__FUNCTION__) + " error(" + + std::to_string(result) + "): " + avro_strerror()); } const auto writer = Writer(&root); - Parser>::write(writer, _obj, - typename ParentType::Root{}); - size_t size = 0; - result = avro_value_sizeof(&root, &size); - if (result != 0) { - throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): " + avro_strerror()); - } - std::vector buffer(size); - avro_writer_t avro_writer = avro_writer_memory(buffer.data(), buffer.size()); - result = avro_value_write(avro_writer, &root); - if (result != 0) { - throw std::runtime_error(std::string(__FUNCTION__) + " error("+ std::to_string(result)+"): " + avro_strerror()); - } + const auto buffer = [&]() -> Result> { + try { + Parser>::write(writer, _obj, + typename ParentType::Root{}); + } catch (std::exception& e) { + return error(e.what()); + } + size_t size = 0; + result = avro_value_sizeof(&root, &size); + if (result != 0) { + return error(std::string(__FUNCTION__) + " error(" + + std::to_string(result) + "): " + avro_strerror()); + } + std::vector buffer(size); + avro_writer_t avro_writer = + avro_writer_memory(buffer.data(), buffer.size()); + result = avro_value_write(avro_writer, &root); + if (result != 0) { + avro_writer_free(avro_writer); + return error(std::string(__FUNCTION__) + " error(" + + std::to_string(result) + "): " + avro_strerror()); + } + avro_writer_free(avro_writer); + return buffer; + }(); avro_value_decref(&root); - avro_writer_free(avro_writer); - return buffer; + return buffer.value(); } /// Returns AVRO bytes. diff --git a/include/rfl/bson/write.hpp b/include/rfl/bson/write.hpp index ec3d345db..ebaf55a7b 100644 --- a/include/rfl/bson/write.hpp +++ b/include/rfl/bson/write.hpp @@ -7,6 +7,7 @@ #include #include "../Processors.hpp" +#include "../Result.hpp" #include "../internal/ptr_cast.hpp" #include "../parsing/Parent.hpp" #include "Parser.hpp" @@ -17,7 +18,7 @@ namespace bson { /// Returns BSON bytes. Careful: It is the responsibility of the caller to call /// bson_free on the returned pointer. template -std::pair to_buffer(const auto& _obj) { +Result> to_buffer(const auto& _obj) noexcept { using T = std::remove_cvref_t; using ParentType = parsing::Parent; bson_t* doc = nullptr; @@ -31,30 +32,46 @@ std::pair to_buffer(const auto& _obj) { static_assert(!ProcessorsType::no_field_names_, "The NoFieldNames processor is not supported for BSON, XML, " "TOML, or YAML."); - Parser::write(rfl_writer, _obj, - typename ParentType::Root{}); + const auto nothing = [&]() -> Result { + try { + Parser::write(rfl_writer, _obj, + typename ParentType::Root{}); + return Nothing{}; + } catch (const std::exception& e) { + return error(e.what()); + } + }(); bson_writer_end(bson_writer); const auto len = bson_writer_get_length(bson_writer); bson_writer_destroy(bson_writer); - return std::make_pair(buf, len); + return nothing.transform( + [&](const auto&) { return std::make_pair(buf, len); }); } /// Returns BSON bytes. template std::vector write(const auto& _obj) { - auto [buf, len] = to_buffer(_obj); - const auto result = std::vector(internal::ptr_cast(buf), - internal::ptr_cast(buf) + len); - bson_free(buf); - return result; + return to_buffer(_obj) + .transform([](const auto& _p) { + const auto vec = + std::vector(internal::ptr_cast(_p.first), + internal::ptr_cast(_p.first) + _p.second); + bson_free(_p.first); + return vec; + }) + .value(); } /// Writes a BSON into an ostream. template std::ostream& write(const auto& _obj, std::ostream& _stream) { - auto [buf, len] = to_buffer(_obj); - _stream.write(internal::ptr_cast(buf), len); - bson_free(buf); + to_buffer(_obj) + .transform([&](const auto& _p) { + _stream.write(internal::ptr_cast(_p.first), _p.second); + bson_free(_p.first); + return Nothing{}; + }) + .value(); return _stream; } From a3f0529adc2066194a324a9a6fb14527f33aefc1 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 18:57:57 +0100 Subject: [PATCH 06/18] Use RAII for JSON --- include/rfl/json/Writer.hpp | 25 +++++++++++++++---------- include/rfl/json/write.hpp | 10 ++++------ src/rfl/json/Writer.cpp | 34 ++++++++++++++++++---------------- 3 files changed, 37 insertions(+), 32 deletions(-) diff --git a/include/rfl/json/Writer.hpp b/include/rfl/json/Writer.hpp index 7337002f6..decf08424 100644 --- a/include/rfl/json/Writer.hpp +++ b/include/rfl/json/Writer.hpp @@ -7,6 +7,7 @@ #include "../thirdparty/yyjson.h" #endif +#include #include #include #include @@ -44,7 +45,11 @@ class RFL_API Writer { using OutputObjectType = YYJSONOutputObject; using OutputVarType = YYJSONOutputVar; - Writer(yyjson_mut_doc* _doc); + Writer(); + + ~Writer() = default; + + yyjson_mut_doc* doc() const { return doc_.get(); } OutputArrayType array_as_root(const size_t) const noexcept; @@ -55,7 +60,7 @@ class RFL_API Writer { template OutputVarType value_as_root(const T& _var) const noexcept { const auto val = from_basic_type(_var); - yyjson_mut_doc_set_root(doc_, val.val_); + yyjson_mut_doc_set_root(doc(), val.val_); return OutputVarType(val); } @@ -90,7 +95,7 @@ class RFL_API Writer { OutputObjectType* _parent) const { const auto val = from_basic_type(_var); const bool ok = yyjson_mut_obj_add( - _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), val.val_); + _parent->val_, yyjson_mut_strcpy(doc(), _name.data()), val.val_); if (!ok) { throw std::runtime_error("Could not add field '" + std::string(_name) + "' to object."); @@ -111,27 +116,27 @@ class RFL_API Writer { template OutputVarType from_basic_type(const T& _var) const noexcept { if constexpr (std::is_same, std::string>()) { - return OutputVarType(yyjson_mut_strcpy(doc_, _var.c_str())); + return OutputVarType(yyjson_mut_strcpy(doc(), _var.c_str())); } else if constexpr (std::is_same, bool>()) { - return OutputVarType(yyjson_mut_bool(doc_, _var)); + return OutputVarType(yyjson_mut_bool(doc(), _var)); } else if constexpr (std::is_floating_point>()) { - return OutputVarType(yyjson_mut_real(doc_, static_cast(_var))); + return OutputVarType(yyjson_mut_real(doc(), static_cast(_var))); } else if constexpr (std::is_unsigned>()) { - return OutputVarType(yyjson_mut_uint(doc_, static_cast(_var))); + return OutputVarType(yyjson_mut_uint(doc(), static_cast(_var))); } else if constexpr (std::is_integral>()) { - return OutputVarType(yyjson_mut_int(doc_, static_cast(_var))); + return OutputVarType(yyjson_mut_int(doc(), static_cast(_var))); } else { static_assert(rfl::always_false_v, "Unsupported type."); } } - public: - yyjson_mut_doc* doc_; + private: + std::shared_ptr doc_; }; } // namespace json diff --git a/include/rfl/json/write.hpp b/include/rfl/json/write.hpp index 2f08d6dbf..0b5696388 100644 --- a/include/rfl/json/write.hpp +++ b/include/rfl/json/write.hpp @@ -26,18 +26,17 @@ template std::string write(const auto& _obj, const yyjson_write_flag _flag = 0) { using T = std::remove_cvref_t; using ParentType = parsing::Parent; - auto w = Writer(yyjson_mut_doc_new(NULL)); + auto w = Writer(); Parser>::write(w, _obj, typename ParentType::Root{}); yyjson_write_err err; const char* json_c_str = - yyjson_mut_write_opts(w.doc_, _flag, NULL, NULL, &err); + yyjson_mut_write_opts(w.doc(), _flag, NULL, NULL, &err); if (!json_c_str) { throw std::runtime_error("An error occured while writing to JSON: " + std::string(err.msg)); } const auto json_str = std::string(json_c_str); free((void*)json_c_str); - yyjson_mut_doc_free(w.doc_); return json_str; } @@ -47,18 +46,17 @@ std::ostream& write(const auto& _obj, std::ostream& _stream, const yyjson_write_flag _flag = 0) { using T = std::remove_cvref_t; using ParentType = parsing::Parent; - auto w = Writer(yyjson_mut_doc_new(NULL)); + auto w = Writer(); Parser>::write(w, _obj, typename ParentType::Root{}); yyjson_write_err err; const char* json_c_str = - yyjson_mut_write_opts(w.doc_, _flag, NULL, NULL, &err); + yyjson_mut_write_opts(w.doc(), _flag, NULL, NULL, &err); if (!json_c_str) { throw std::runtime_error("An error occured while writing to JSON: " + std::string(err.msg)); } _stream << json_c_str; free((void*)json_c_str); - yyjson_mut_doc_free(w.doc_); return _stream; } diff --git a/src/rfl/json/Writer.cpp b/src/rfl/json/Writer.cpp index 2a1d26fe0..e4992e47b 100644 --- a/src/rfl/json/Writer.cpp +++ b/src/rfl/json/Writer.cpp @@ -28,29 +28,31 @@ SOFTWARE. namespace rfl::json { -Writer::Writer(yyjson_mut_doc* _doc) : doc_(_doc) {} +Writer::Writer() + : doc_(std::shared_ptr(yyjson_mut_doc_new(NULL), + yyjson_mut_doc_free)) {} Writer::OutputArrayType Writer::array_as_root(const size_t) const noexcept { - const auto arr = yyjson_mut_arr(doc_); - yyjson_mut_doc_set_root(doc_, arr); + const auto arr = yyjson_mut_arr(doc()); + yyjson_mut_doc_set_root(doc(), arr); return OutputArrayType(arr); } Writer::OutputObjectType Writer::object_as_root(const size_t) const noexcept { - const auto obj = yyjson_mut_obj(doc_); - yyjson_mut_doc_set_root(doc_, obj); + const auto obj = yyjson_mut_obj(doc()); + yyjson_mut_doc_set_root(doc(), obj); return OutputObjectType(obj); } Writer::OutputVarType Writer::null_as_root() const noexcept { - const auto null = yyjson_mut_null(doc_); - yyjson_mut_doc_set_root(doc_, null); + const auto null = yyjson_mut_null(doc()); + yyjson_mut_doc_set_root(doc(), null); return OutputVarType(null); } Writer::OutputArrayType Writer::add_array_to_array( const size_t, OutputArrayType* _parent) const { - const auto arr = yyjson_mut_arr(doc_); + const auto arr = yyjson_mut_arr(doc()); const bool ok = yyjson_mut_arr_add_val(_parent->val_, arr); if (!ok) { throw std::runtime_error("Adding an array to an array failed."); @@ -61,9 +63,9 @@ Writer::OutputArrayType Writer::add_array_to_array( Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t, OutputObjectType* _parent) const { - const auto arr = yyjson_mut_arr(doc_); + const auto arr = yyjson_mut_arr(doc()); const bool ok = yyjson_mut_obj_add( - _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), arr); + _parent->val_, yyjson_mut_strcpy(doc(), _name.data()), arr); if (!ok) { throw std::runtime_error("Could not add field '" + std::string(_name) + "' to object."); @@ -73,7 +75,7 @@ Writer::OutputArrayType Writer::add_array_to_object( Writer::OutputObjectType Writer::add_object_to_array( const size_t, OutputArrayType* _parent) const { - const auto obj = yyjson_mut_obj(doc_); + const auto obj = yyjson_mut_obj(doc()); const bool ok = yyjson_mut_arr_add_val(_parent->val_, obj); if (!ok) { throw std::runtime_error("Adding an object to an array failed."); @@ -84,9 +86,9 @@ Writer::OutputObjectType Writer::add_object_to_array( Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t, OutputObjectType* _parent) const { - const auto obj = yyjson_mut_obj(doc_); + const auto obj = yyjson_mut_obj(doc()); const auto ok = yyjson_mut_obj_add( - _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), obj); + _parent->val_, yyjson_mut_strcpy(doc(), _name.data()), obj); if (!ok) { throw std::runtime_error("Could not add field '" + std::string(_name) + "' to object."); @@ -96,7 +98,7 @@ Writer::OutputObjectType Writer::add_object_to_object( Writer::OutputVarType Writer::add_null_to_array( OutputArrayType* _parent) const { - const auto null = yyjson_mut_null(doc_); + const auto null = yyjson_mut_null(doc()); const bool ok = yyjson_mut_arr_add_val(_parent->val_, null); if (!ok) { throw std::runtime_error("Adding null to an array failed."); @@ -106,9 +108,9 @@ Writer::OutputVarType Writer::add_null_to_array( Writer::OutputVarType Writer::add_null_to_object( const std::string_view& _name, OutputObjectType* _parent) const { - const auto null = yyjson_mut_null(doc_); + const auto null = yyjson_mut_null(doc()); const bool ok = yyjson_mut_obj_add( - _parent->val_, yyjson_mut_strcpy(doc_, _name.data()), null); + _parent->val_, yyjson_mut_strcpy(doc(), _name.data()), null); if (!ok) { throw std::runtime_error("Could not add field '" + std::string(_name) + "' to object."); From 11a3a974692be0a848e7ece7726ca15da90fe3ca Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 19:04:36 +0100 Subject: [PATCH 07/18] Use RAII for BSON --- include/rfl/bson/write.hpp | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/include/rfl/bson/write.hpp b/include/rfl/bson/write.hpp index ebaf55a7b..1603475ad 100644 --- a/include/rfl/bson/write.hpp +++ b/include/rfl/bson/write.hpp @@ -3,6 +3,7 @@ #include +#include #include #include @@ -24,9 +25,10 @@ Result> to_buffer(const auto& _obj) noexcept { bson_t* doc = nullptr; uint8_t* buf = nullptr; size_t buflen = 0; - bson_writer_t* bson_writer = - bson_writer_new(&buf, &buflen, 0, bson_realloc_ctx, NULL); - bson_writer_begin(bson_writer, &doc); + auto bson_writer = std::shared_ptr( + bson_writer_new(&buf, &buflen, 0, bson_realloc_ctx, NULL), + bson_writer_destroy); + bson_writer_begin(bson_writer.get(), &doc); const auto rfl_writer = Writer(doc); using ProcessorsType = Processors; static_assert(!ProcessorsType::no_field_names_, @@ -41,11 +43,14 @@ Result> to_buffer(const auto& _obj) noexcept { return error(e.what()); } }(); - bson_writer_end(bson_writer); - const auto len = bson_writer_get_length(bson_writer); - bson_writer_destroy(bson_writer); - return nothing.transform( - [&](const auto&) { return std::make_pair(buf, len); }); + bson_writer_end(bson_writer.get()); + const auto len = bson_writer_get_length(bson_writer.get()); + return nothing + .transform([&](const auto&) { return std::make_pair(buf, len); }) + .or_else([&](auto&& _err) { + bson_free(buf); + return error(_err.what()); + }); } /// Returns BSON bytes. From a7279bd6cd72a535f36442efc1f2ca4ab0dee6f7 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 19:47:14 +0100 Subject: [PATCH 08/18] Removed the noexcept into cbor --- include/rfl/cbor/Writer.hpp | 44 ++++---- src/rfl/cbor/Writer.cpp | 28 +++-- tests/cbor/test_read_byte_containers.cpp | 126 +++++++++-------------- tests/cbor/test_variant_auto_tagging.cpp | 55 +++++----- 4 files changed, 117 insertions(+), 136 deletions(-) diff --git a/include/rfl/cbor/Writer.hpp b/include/rfl/cbor/Writer.hpp index 4922e9751..c6e99f8fb 100644 --- a/include/rfl/cbor/Writer.hpp +++ b/include/rfl/cbor/Writer.hpp @@ -6,10 +6,10 @@ #include #include -//#include "../Box.hpp" +// #include "../Box.hpp" #include "../Bytestring.hpp" -//#include "../Ref.hpp" -//#include "../Result.hpp" +// #include "../Ref.hpp" +// #include "../Result.hpp" #include "../Vectorstring.hpp" #include "../always_false.hpp" #include "../common.hpp" @@ -34,61 +34,61 @@ class RFL_API Writer { ~Writer(); - OutputArrayType array_as_root(const size_t _size) const noexcept; + OutputArrayType array_as_root(const size_t _size) const; - OutputObjectType object_as_root(const size_t) const noexcept; + OutputObjectType object_as_root(const size_t) const; - OutputVarType null_as_root() const noexcept; + OutputVarType null_as_root() const; template - OutputVarType value_as_root(const T& _var) const noexcept { + OutputVarType value_as_root(const T& _var) const { return new_value(_var); } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t, + OutputObjectType* _parent) const; template OutputVarType add_value_to_array(const T& _var, - OutputArrayType* /*_parent*/) const noexcept { + OutputArrayType* /*_parent*/) const { return new_value(_var); } template OutputVarType add_value_to_object(const std::string_view& _name, const T& _var, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { encoder_->key(_name); return new_value(_var); } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; - void end_array(OutputArrayType* _arr) const noexcept; + void end_array(OutputArrayType* _arr) const; - void end_object(OutputObjectType* _obj) const noexcept; + void end_object(OutputObjectType* _obj) const; private: - OutputArrayType new_array(const size_t _size) const noexcept; + OutputArrayType new_array(const size_t _size) const; - OutputObjectType new_object() const noexcept; + OutputObjectType new_object() const; template - OutputVarType new_value(const T& _var) const noexcept { + OutputVarType new_value(const T& _var) const { if constexpr (std::is_same, std::string>()) { encoder_->string_value(_var); } else if constexpr (std::is_same, diff --git a/src/rfl/cbor/Writer.cpp b/src/rfl/cbor/Writer.cpp index 72fe4bd68..754545181 100644 --- a/src/rfl/cbor/Writer.cpp +++ b/src/rfl/cbor/Writer.cpp @@ -6,72 +6,70 @@ Writer::Writer(Encoder* _encoder) : encoder_(_encoder) {} Writer::~Writer() = default; -Writer::OutputArrayType Writer::array_as_root( - const size_t _size) const noexcept { +Writer::OutputArrayType Writer::array_as_root(const size_t _size) const { return new_array(_size); } -Writer::OutputObjectType Writer::object_as_root( - const size_t) const noexcept { +Writer::OutputObjectType Writer::object_as_root(const size_t) const { return new_object(); } -Writer::OutputVarType Writer::null_as_root() const noexcept { +Writer::OutputVarType Writer::null_as_root() const { encoder_->null_value(); return OutputVarType{}; } Writer::OutputArrayType Writer::add_array_to_array( - const size_t _size, OutputArrayType* /*_parent*/) const noexcept { + const size_t _size, OutputArrayType* /*_parent*/) const { return new_array(_size); } Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t _size, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { encoder_->key(_name); return new_array(_size); } Writer::OutputObjectType Writer::add_object_to_array( - const size_t, OutputArrayType* /*_parent*/) const noexcept { + const size_t, OutputArrayType* /*_parent*/) const { return new_object(); } Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { encoder_->key(_name); return new_object(); } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* /*_parent*/) const noexcept { + OutputArrayType* /*_parent*/) const { encoder_->null_value(); return OutputVarType{}; } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept { + const std::string_view& _name, OutputObjectType* /*_parent*/) const { encoder_->key(_name); encoder_->null_value(); return OutputVarType{}; } -void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept { +void Writer::end_array(OutputArrayType* /*_arr*/) const { encoder_->end_array(); } -void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept { +void Writer::end_object(OutputObjectType* /*_obj*/) const { encoder_->end_object(); } -Writer::OutputArrayType Writer::new_array(const size_t _size) const noexcept { +Writer::OutputArrayType Writer::new_array(const size_t _size) const { encoder_->begin_array(_size); return OutputArrayType{}; } -Writer::OutputObjectType Writer::new_object() const noexcept { +Writer::OutputObjectType Writer::new_object() const { encoder_->begin_object(); return OutputObjectType{}; } diff --git a/tests/cbor/test_read_byte_containers.cpp b/tests/cbor/test_read_byte_containers.cpp index ae428512e..ed863b469 100644 --- a/tests/cbor/test_read_byte_containers.cpp +++ b/tests/cbor/test_read_byte_containers.cpp @@ -1,90 +1,66 @@ +#include + #include #include #include -#include - // Make sure things still compile when // rfl.hpp is included after rfl/cbor.hpp. #include -namespace test_read_byte_containers -{ +namespace test_read_byte_containers { -struct TestBox -{ - int length; - int width; - int height; +struct TestBox { + int length; + int width; + int height; }; -// TODO: Apparently the jsoncons trait is_byte_sequence is not working for std::span. -// TEST(cbor, test_read_from_char_span) -// { - -// TestBox b = { -// .length = 1, -// .width = 2, -// .height = 3, -// }; - - -// std::vector rfl_buffer = rfl::cbor::write(s); - -// // I don't want to be forced to copy to a std::vector if that's not what data strucure I use. -// // So, allow reading from a std::span -// std::span span(rfl_buffer.data(), rfl_buffer.size()); - -// auto result = rfl::cbor::read(span); -// EXPECT_TRUE(result); -// EXPECT_EQ(result->one, 1); -// EXPECT_EQ(result->two, 2); -// } - -TEST(cbor, test_read_from_byte_view) -{ - TestBox b = { - .length = 1, - .width = 2, - .height = 3, - }; - - // TODO: Write directly into desired container, once rfl::cbor::write supports it. - std::vector rfl_buffer = rfl::cbor::write(b); - - std::array my_buffer; - std::transform(rfl_buffer.begin(), rfl_buffer.end(), my_buffer.begin(), - [](char c) { return static_cast(c); }); - - std::basic_string_view byte_view(my_buffer.data(), rfl_buffer.size()); - - auto result = rfl::cbor::read(byte_view); - EXPECT_TRUE(result); - EXPECT_EQ(result->length, 1); - EXPECT_EQ(result->width, 2); - EXPECT_EQ(result->height, 3); +TEST(cbor, test_read_from_byte_view) { + TestBox b = { + .length = 1, + .width = 2, + .height = 3, + }; + + // TODO: Write directly into desired container, once rfl::cbor::write supports + // it. + std::vector rfl_buffer = rfl::cbor::write(b); + + std::array my_buffer; + std::transform(rfl_buffer.begin(), rfl_buffer.end(), my_buffer.begin(), + [](char c) { return static_cast(c); }); + + std::basic_string_view byte_view(my_buffer.data(), + rfl_buffer.size()); + + auto result = rfl::cbor::read(byte_view); + EXPECT_TRUE(result); + EXPECT_EQ(result->length, 1); + EXPECT_EQ(result->width, 2); + EXPECT_EQ(result->height, 3); } -TEST(cbor, test_read_from_uint8_array) -{ - TestBox b = { - .length = 4, - .width = 5, - .height = 6, - }; - - // TODO: Write directly into desired container, once rfl::cbor::write supports it. - std::vector rfl_buffer = rfl::cbor::write(b); - - std::array my_buffer; - std::transform(rfl_buffer.begin(), rfl_buffer.end(), my_buffer.begin(), - [](char c) { return static_cast(c); }); - - auto result = rfl::cbor::read(my_buffer); - EXPECT_TRUE(result); - EXPECT_EQ(result->length, 4); - EXPECT_EQ(result->width, 5); - EXPECT_EQ(result->height, 6); +TEST(cbor, test_read_from_uint8_array) { + TestBox b = { + .length = 4, + .width = 5, + .height = 6, + }; + + // TODO: Write directly into desired container, once rfl::cbor::write supports + // it. + std::vector rfl_buffer = rfl::cbor::write(b); + + std::array my_buffer; + std::transform(rfl_buffer.begin(), rfl_buffer.end(), my_buffer.begin(), + [](char c) { return static_cast(c); }); + + auto result = rfl::cbor::read(my_buffer); + EXPECT_TRUE(result); + EXPECT_EQ(result->length, 4); + EXPECT_EQ(result->width, 5); + EXPECT_EQ(result->height, 6); } -} // namespace test_read_byte_containers \ No newline at end of file +} // namespace test_read_byte_containers diff --git a/tests/cbor/test_variant_auto_tagging.cpp b/tests/cbor/test_variant_auto_tagging.cpp index c8ab2e0d0..642304b44 100644 --- a/tests/cbor/test_variant_auto_tagging.cpp +++ b/tests/cbor/test_variant_auto_tagging.cpp @@ -6,8 +6,8 @@ #include "write_and_read.hpp" // NOTE TO MAINTAINERS: -// These tests are very similar to the others in test_add_*tags_to_*variants.cpp, so please keep them -// in sync. +// These tests are very similar to the others in +// test_add_*tags_to_*variants.cpp, so please keep them in sync. namespace test_variant_auto_tagging { // test 1 -> normal behaviour @@ -34,10 +34,12 @@ TEST(cbor, test_add_tags_to_rfl_variants) { vec.emplace_back(key_pressed_t{'c'}); vec.emplace_back(3); write_and_read( - vec, - // Diagnostic notation: [{_ "button_pressed_t": {_ }}, {_ "button_released_t": {_ "button": 4}}, {_ "key_pressed": {_ "key": 99}}, {_ "int": 3}] - // See: https://cbor.me/?diag=[{_%20%22button_pressed_t%22:%20{_%20}},%20{_%20%22button_released_t%22:%20{_%20%22button%22:%204}},%20{_%20%22key_pressed%22:%20{_%20%22key%22:%2099}},%20{_%20%22int%22:%203}] - R"( + vec, + // Diagnostic notation: [{_ "button_pressed_t": {_ }}, {_ + // "button_released_t": {_ "button": 4}}, {_ "key_pressed": {_ "key": + // 99}}, {_ "int": 3}] See: + // https://cbor.me/?diag=[{_%20%22button_pressed_t%22:%20{_%20}},%20{_%20%22button_released_t%22:%20{_%20%22button%22:%204}},%20{_%20%22key_pressed%22:%20{_%20%22key%22:%2099}},%20{_%20%22int%22:%203}] + R"( 84 # array(4) BF # map(*) 70 # text(16) @@ -72,9 +74,10 @@ TEST(cbor, test_add_tags_to_rfl_variants) { } // test 2 -> 'Generic' within a struct like this can be read/written with -// rfl::AddNamespacedTagsToVariants so that the underlying `std::variant` holds two 'Generic' fields -// with different namespaces. See the similar test in test_add_tags_to_variants.cpp. -// A hypothetical alternative would be adding an optional manual tag to rfl::Generic +// rfl::AddNamespacedTagsToVariants so that the underlying `std::variant` holds +// two 'Generic' fields with different namespaces. See the similar test in +// test_add_tags_to_variants.cpp. A hypothetical alternative would be adding an +// optional manual tag to rfl::Generic struct APIResult { rfl::Generic result; @@ -86,15 +89,15 @@ struct APIError { using APICallOutput = std::variant; TEST(cbor, test_add_namespaced_tags_to_variants_with_generic) { - std::vector output = { - APIResult{"200"}, - APIError{"an error"} - }; + std::vector output = {APIResult{"200"}, APIError{"an error"}}; write_and_read( - output, - // Diagnostic notation: [{_ "test_variant_auto_tagging::APIResult": {_ "result": {_ "std::string": "200"}}}, {_ "test_variant_auto_tagging::APIError": {_ "error": {_ "std::string": "an error"}}}] - // See: https://cbor.me/?diag=[{_%20%22test_variant_auto_tagging::APIResult%22:%20{_%20%22result%22:%20{_%20%22std::string%22:%20%22200%22}}},%20{_%20%22test_variant_auto_tagging::APIError%22:%20{_%20%22error%22:%20{_%20%22std::string%22:%20%22an%20error%22}}}] - R"( + output, + // Diagnostic notation: [{_ "test_variant_auto_tagging::APIResult": {_ + // "result": {_ "std::string": "200"}}}, {_ + // "test_variant_auto_tagging::APIError": {_ "error": {_ "std::string": + // "an error"}}}] See: + // https://cbor.me/?diag=[{_%20%22test_variant_auto_tagging::APIResult%22:%20{_%20%22result%22:%20{_%20%22std::string%22:%20%22200%22}}},%20{_%20%22test_variant_auto_tagging::APIError%22:%20{_%20%22error%22:%20{_%20%22std::string%22:%20%22an%20error%22}}}] + R"( 82 # array(2) BF # map(*) 78 24 # text(36) @@ -145,15 +148,19 @@ struct Message { using Messages = std::variant; -TEST(json, test_add_namespaced_tags_to_variants_different_namespaces) { +TEST(cbor, test_add_namespaced_tags_to_variants_different_namespaces) { std::vector msgs{ - Result::Message{.result="a result"}, - Error::Message{.error="an error", .error_id=2}, + Result::Message{.result = "a result"}, + Error::Message{.error = "an error", .error_id = 2}, }; - write_and_read(msgs, - // Diagnostic notation: [{_ "test_variant_auto_tagging::Result::Message":{_ "result":"a result"}},{_ "test_variant_auto_tagging::Error::Message":{_ "error":"an error", "error_id":2}}] - // See: https://cbor.me/?diag=[{_%20%22test_variant_auto_tagging::Result::Message%22:{_%20%22result%22:%22a%20result%22}},{_%20%22test_variant_auto_tagging::Error::Message%22:{_%20%22error%22:%22an%20error%22,%20%22error_id%22:2}}] - R"( + write_and_read( + msgs, + // Diagnostic notation: [{_ + // "test_variant_auto_tagging::Result::Message":{_ "result":"a + // result"}},{_ "test_variant_auto_tagging::Error::Message":{_ "error":"an + // error", "error_id":2}}] See: + // https://cbor.me/?diag=[{_%20%22test_variant_auto_tagging::Result::Message%22:{_%20%22result%22:%22a%20result%22}},{_%20%22test_variant_auto_tagging::Error::Message%22:{_%20%22error%22:%22an%20error%22,%20%22error_id%22:2}}] + R"( 82 # array(2) BF # map(*) 78 2A # text(42) From 7c57cbfcddc01706ec0718b422b1a2160b4fc1e0 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 19:47:27 +0100 Subject: [PATCH 09/18] Make msgpack --- include/rfl/msgpack/write.hpp | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/include/rfl/msgpack/write.hpp b/include/rfl/msgpack/write.hpp index 874ca0588..08efd2d87 100644 --- a/include/rfl/msgpack/write.hpp +++ b/include/rfl/msgpack/write.hpp @@ -6,6 +6,7 @@ #include #include "../Processors.hpp" +#include "../Result.hpp" #include "../parsing/Parent.hpp" #include "Parser.hpp" @@ -21,10 +22,16 @@ std::vector write(const auto& _obj) { msgpack_packer pk; msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); auto w = Writer(&pk); - Parser>::write(w, _obj, typename ParentType::Root{}); - auto bytes = std::vector(sbuf.data, sbuf.data + sbuf.size); + const auto bytes = [&]() -> Result> { + try { + Parser>::write(w, _obj, typename ParentType::Root{}); + return std::vector(sbuf.data, sbuf.data + sbuf.size); + } catch (const std::exception& e) { + return error(e.what()); + } + }(); msgpack_sbuffer_destroy(&sbuf); - return bytes; + return bytes.value(); } /// Writes a MSGPACK into an ostream. From 4d71bf21713c67e326e730107687b1e9c51174c8 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 20:29:39 +0100 Subject: [PATCH 10/18] Removed noexcept from CBOR write --- include/rfl/cbor/write.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/rfl/cbor/write.hpp b/include/rfl/cbor/write.hpp index fad768760..162eea894 100644 --- a/include/rfl/cbor/write.hpp +++ b/include/rfl/cbor/write.hpp @@ -13,7 +13,7 @@ namespace rfl::cbor { /// Returns CBOR bytes. template -std::vector write(const auto& _obj) noexcept { +std::vector write(const auto& _obj) { using T = std::remove_cvref_t; using ParentType = parsing::Parent; std::vector buffer; @@ -28,7 +28,7 @@ std::vector write(const auto& _obj) noexcept { /// Writes a CBOR into an ostream. template -std::ostream& write(const auto& _obj, std::ostream& _stream) noexcept { +std::ostream& write(const auto& _obj, std::ostream& _stream) { auto buffer = write(_obj); _stream.write(buffer.data(), buffer.size()); return _stream; From f18ccae05d18ed32cf41091b0a19dedee670c934 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 20:34:03 +0100 Subject: [PATCH 11/18] Removed the noexcept for flexbuffers --- include/rfl/flexbuf/Writer.hpp | 50 +++++++++++++++++----------------- src/rfl/flexbuf/Writer.cpp | 35 ++++++++++++------------ 2 files changed, 42 insertions(+), 43 deletions(-) diff --git a/include/rfl/flexbuf/Writer.hpp b/include/rfl/flexbuf/Writer.hpp index bf4c85b38..47ba42b8b 100644 --- a/include/rfl/flexbuf/Writer.hpp +++ b/include/rfl/flexbuf/Writer.hpp @@ -36,57 +36,57 @@ struct RFL_API Writer { ~Writer(); - OutputArrayType array_as_root(const size_t _size) const noexcept; + OutputArrayType array_as_root(const size_t _size) const; - OutputObjectType object_as_root(const size_t _size) const noexcept; + OutputObjectType object_as_root(const size_t _size) const; - OutputVarType null_as_root() const noexcept; + OutputVarType null_as_root() const; template - OutputVarType value_as_root(const T& _var) const noexcept { + OutputVarType value_as_root(const T& _var) const { return insert_value(_var); } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t _size, + OutputObjectType* _parent) const; template - OutputVarType add_value_to_array( - const T& _var, OutputArrayType* /*_parent*/) const noexcept { + OutputVarType add_value_to_array(const T& _var, + OutputArrayType* /*_parent*/) const { return insert_value(_var); } template - OutputVarType add_value_to_object( - const std::string_view& _name, const T& _var, - OutputObjectType* /*_parent*/) const noexcept { + OutputVarType add_value_to_object(const std::string_view& _name, + const T& _var, + OutputObjectType* /*_parent*/) const { return insert_value(_name, _var); } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; - void end_array(OutputArrayType* _arr) const noexcept; + void end_array(OutputArrayType* _arr) const; - void end_object(OutputObjectType* _obj) const noexcept; + void end_object(OutputObjectType* _obj) const; private: template OutputVarType insert_value(const std::string_view& _name, - const T& _var) const noexcept { + const T& _var) const { if constexpr (std::is_same, std::string>()) { fbb_->String(_name.data(), _var); } else if constexpr (std::is_same, @@ -107,7 +107,7 @@ struct RFL_API Writer { } template - OutputVarType insert_value(const T& _var) const noexcept { + OutputVarType insert_value(const T& _var) const { if constexpr (std::is_same, std::string>()) { fbb_->String(_var); } else if constexpr (std::is_same, @@ -125,13 +125,13 @@ struct RFL_API Writer { return OutputVarType{}; } - OutputArrayType new_array(const std::string_view& _name) const noexcept; + OutputArrayType new_array(const std::string_view& _name) const; - OutputArrayType new_array() const noexcept; + OutputArrayType new_array() const; - OutputObjectType new_object(const std::string_view& _name) const noexcept; + OutputObjectType new_object(const std::string_view& _name) const; - OutputObjectType new_object() const noexcept; + OutputObjectType new_object() const; private: Ref fbb_; diff --git a/src/rfl/flexbuf/Writer.cpp b/src/rfl/flexbuf/Writer.cpp index 5ca1ea2be..f635c8c32 100644 --- a/src/rfl/flexbuf/Writer.cpp +++ b/src/rfl/flexbuf/Writer.cpp @@ -1,86 +1,85 @@ #include "rfl/flexbuf/Writer.hpp" +#include + namespace rfl::flexbuf { Writer::Writer(const Ref& _fbb) : fbb_(_fbb) {} Writer::~Writer() = default; -Writer::OutputArrayType Writer::array_as_root( - const size_t /*_size*/) const noexcept { +Writer::OutputArrayType Writer::array_as_root(const size_t /*_size*/) const { return new_array(); } -Writer::OutputObjectType Writer::object_as_root( - const size_t /*_size*/) const noexcept { +Writer::OutputObjectType Writer::object_as_root(const size_t /*_size*/) const { return new_object(); } -Writer::OutputVarType Writer::null_as_root() const noexcept { +Writer::OutputVarType Writer::null_as_root() const { fbb_->Null(); return OutputVarType{}; } Writer::OutputArrayType Writer::add_array_to_array( - const size_t /*_size*/, OutputArrayType* /*_parent*/) const noexcept { + const size_t /*_size*/, OutputArrayType* /*_parent*/) const { return new_array(); } Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { return new_array(_name); } Writer::OutputObjectType Writer::add_object_to_array( - const size_t /*_size*/, OutputArrayType* /*_parent*/) const noexcept { + const size_t /*_size*/, OutputArrayType* /*_parent*/) const { return new_object(); } Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { return new_object(_name); } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* /*_parent*/) const noexcept { + OutputArrayType* /*_parent*/) const { fbb_->Null(); return OutputVarType{}; } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept { + const std::string_view& _name, OutputObjectType* /*_parent*/) const { fbb_->Null(_name.data()); return OutputVarType{}; } -void Writer::end_array(OutputArrayType* _arr) const noexcept { +void Writer::end_array(OutputArrayType* _arr) const { fbb_->EndVector(_arr->start_, false, false); } -void Writer::end_object(OutputObjectType* _obj) const noexcept { +void Writer::end_object(OutputObjectType* _obj) const { fbb_->EndMap(_obj->start_); } -Writer::OutputArrayType Writer::new_array( - const std::string_view& _name) const noexcept { +Writer::OutputArrayType Writer::new_array(const std::string_view& _name) const { const auto start = fbb_->StartVector(_name.data()); return OutputArrayType{start}; } -Writer::OutputArrayType Writer::new_array() const noexcept { +Writer::OutputArrayType Writer::new_array() const { const auto start = fbb_->StartVector(); return OutputArrayType{start}; } Writer::OutputObjectType Writer::new_object( - const std::string_view& _name) const noexcept { + const std::string_view& _name) const { const auto start = fbb_->StartMap(_name.data()); return OutputObjectType{start}; } -Writer::OutputObjectType Writer::new_object() const noexcept { +Writer::OutputObjectType Writer::new_object() const { const auto start = fbb_->StartMap(); return OutputObjectType{start}; } From 81ed222404c0719dc41834a3adb13e3d3aa8892f Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 20:47:50 +0100 Subject: [PATCH 12/18] Added noexcept to toml --- include/rfl/toml/Writer.hpp | 32 ++++++++++++++++---------------- src/rfl/toml/Writer.cpp | 23 ++++++++++------------- 2 files changed, 26 insertions(+), 29 deletions(-) diff --git a/include/rfl/toml/Writer.hpp b/include/rfl/toml/Writer.hpp index afddc3fba..f8ee56390 100644 --- a/include/rfl/toml/Writer.hpp +++ b/include/rfl/toml/Writer.hpp @@ -36,36 +36,36 @@ class RFL_API Writer { ~Writer(); template - OutputArrayType array_as_root(const T _size) const noexcept; + OutputArrayType array_as_root(const T _size) const; - OutputObjectType object_as_root(const size_t _size) const noexcept; + OutputObjectType object_as_root(const size_t _size) const; - OutputVarType null_as_root() const noexcept; + OutputVarType null_as_root() const; template - OutputVarType value_as_root(const T& _var) const noexcept { + OutputVarType value_as_root(const T& _var) const { static_assert(rfl::always_false_v, "TOML only allows tables as the root element."); return OutputVarType{}; } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t _size, + OutputObjectType* _parent) const; template OutputVarType add_value_to_array(const T& _var, - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { _parent->val_->push_back(::toml::value(_var)); return OutputVarType{}; } @@ -73,19 +73,19 @@ class RFL_API Writer { template OutputVarType add_value_to_object(const std::string_view& _name, const T& _var, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { _parent->val_->emplace(_name, ::toml::value(_var)); return OutputVarType{}; } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; - void end_array(OutputArrayType* _arr) const noexcept; + void end_array(OutputArrayType* _arr) const; - void end_object(OutputObjectType* _obj) const noexcept; + void end_object(OutputObjectType* _obj) const; private: ::toml::table* root_; diff --git a/src/rfl/toml/Writer.cpp b/src/rfl/toml/Writer.cpp index d76ee6363..11de0a67d 100644 --- a/src/rfl/toml/Writer.cpp +++ b/src/rfl/toml/Writer.cpp @@ -6,17 +6,14 @@ Writer::Writer(::toml::table* _root) : root_(_root) {} Writer::~Writer() = default; -Writer::OutputObjectType Writer::object_as_root( - const size_t /*_size*/) const noexcept { +Writer::OutputObjectType Writer::object_as_root(const size_t /*_size*/) const { return OutputObjectType{root_}; } -Writer::OutputVarType Writer::null_as_root() const noexcept { - return OutputVarType{}; -} +Writer::OutputVarType Writer::null_as_root() const { return OutputVarType{}; } Writer::OutputArrayType Writer::add_array_to_array( - const size_t /*_size*/, OutputArrayType* _parent) const noexcept { + const size_t /*_size*/, OutputArrayType* _parent) const { const auto i = _parent->val_->size(); _parent->val_->push_back(::toml::array()); return OutputArrayType{_parent->val_->at(i).as_array()}; @@ -24,13 +21,13 @@ Writer::OutputArrayType Writer::add_array_to_array( Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { _parent->val_->emplace(_name, ::toml::array()); return OutputArrayType{_parent->val_->at_path(_name).as_array()}; } Writer::OutputObjectType Writer::add_object_to_array( - const size_t /*_size*/, OutputArrayType* _parent) const noexcept { + const size_t /*_size*/, OutputArrayType* _parent) const { const auto i = _parent->val_->size(); _parent->val_->push_back(::toml::table()); return OutputObjectType{_parent->val_->at(i).as_table()}; @@ -38,25 +35,25 @@ Writer::OutputObjectType Writer::add_object_to_array( Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { _parent->val_->emplace(_name, ::toml::table()); return OutputObjectType{_parent->val_->at_path(_name).as_table()}; } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { _parent->val_->push_back(std::string("")); return OutputVarType{}; } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* _parent) const noexcept { + const std::string_view& _name, OutputObjectType* _parent) const { _parent->val_->emplace(_name, ::toml::value(std::string(""))); return OutputVarType{}; } -void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {} +void Writer::end_array(OutputArrayType* /*_arr*/) const {} -void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {} +void Writer::end_object(OutputObjectType* /*_obj*/) const {} } // namespace rfl::toml From a2f20c91db4c66576a3f08d2dc107653d0f69cee Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 20:55:05 +0100 Subject: [PATCH 13/18] Removed noexcept from ubjson --- include/rfl/ubjson/Writer.hpp | 38 +++++++++++++++++------------------ include/rfl/ubjson/write.hpp | 4 ++-- src/rfl/ubjson/Writer.cpp | 28 ++++++++++++-------------- 3 files changed, 34 insertions(+), 36 deletions(-) diff --git a/include/rfl/ubjson/Writer.hpp b/include/rfl/ubjson/Writer.hpp index a7a09a6e3..0ef7eba3f 100644 --- a/include/rfl/ubjson/Writer.hpp +++ b/include/rfl/ubjson/Writer.hpp @@ -38,61 +38,61 @@ class RFL_API Writer { ~Writer(); - OutputArrayType array_as_root(const size_t _size) const noexcept; + OutputArrayType array_as_root(const size_t _size) const; - OutputObjectType object_as_root(const size_t _size) const noexcept; + OutputObjectType object_as_root(const size_t _size) const; - OutputVarType null_as_root() const noexcept; + OutputVarType null_as_root() const; template - OutputVarType value_as_root(const T& _var) const noexcept { + OutputVarType value_as_root(const T& _var) const { return new_value(_var); } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t _size, + OutputObjectType* _parent) const; template OutputVarType add_value_to_array(const T& _var, - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { return new_value(_var); } template OutputVarType add_value_to_object(const std::string_view& _name, const T& _var, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { encoder_->key(_name); return new_value(_var); } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; - void end_array(OutputArrayType* _arr) const noexcept; + void end_array(OutputArrayType* _arr) const; - void end_object(OutputObjectType* _obj) const noexcept; + void end_object(OutputObjectType* _obj) const; private: - OutputArrayType new_array(const size_t _size) const noexcept; + OutputArrayType new_array(const size_t _size) const; - OutputObjectType new_object(const size_t _size) const noexcept; + OutputObjectType new_object(const size_t _size) const; template - OutputVarType new_value(const T& _var) const noexcept { + OutputVarType new_value(const T& _var) const { if constexpr (std::is_same, std::string>()) { encoder_->string_value(_var); } else if constexpr (std::is_same, diff --git a/include/rfl/ubjson/write.hpp b/include/rfl/ubjson/write.hpp index 65d341db4..c7fadd848 100644 --- a/include/rfl/ubjson/write.hpp +++ b/include/rfl/ubjson/write.hpp @@ -16,7 +16,7 @@ namespace rfl::ubjson { /// Returns UBJSON bytes. template -std::vector write(const auto& _obj) noexcept { +std::vector write(const auto& _obj) { using T = std::remove_cvref_t; using ParentType = parsing::Parent; std::vector buffer; @@ -31,7 +31,7 @@ std::vector write(const auto& _obj) noexcept { /// Writes a UBJSON into an ostream. template -std::ostream& write(const auto& _obj, std::ostream& _stream) noexcept { +std::ostream& write(const auto& _obj, std::ostream& _stream) { auto buffer = write(_obj); _stream.write(buffer.data(), buffer.size()); return _stream; diff --git a/src/rfl/ubjson/Writer.cpp b/src/rfl/ubjson/Writer.cpp index 07c1790ae..22d59ba4d 100644 --- a/src/rfl/ubjson/Writer.cpp +++ b/src/rfl/ubjson/Writer.cpp @@ -6,72 +6,70 @@ Writer::Writer(Encoder* _encoder) : encoder_(_encoder) {} Writer::~Writer() = default; -Writer::OutputArrayType Writer::array_as_root( - const size_t _size) const noexcept { +Writer::OutputArrayType Writer::array_as_root(const size_t _size) const { return new_array(_size); } -Writer::OutputObjectType Writer::object_as_root( - const size_t _size) const noexcept { +Writer::OutputObjectType Writer::object_as_root(const size_t _size) const { return new_object(_size); } -Writer::OutputVarType Writer::null_as_root() const noexcept { +Writer::OutputVarType Writer::null_as_root() const { encoder_->null_value(); return OutputVarType{}; } Writer::OutputArrayType Writer::add_array_to_array( - const size_t _size, OutputArrayType* /*_parent*/) const noexcept { + const size_t _size, OutputArrayType* /*_parent*/) const { return new_array(_size); } Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t _size, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { encoder_->key(_name); return new_array(_size); } Writer::OutputObjectType Writer::add_object_to_array( - const size_t _size, OutputArrayType* /*_parent*/) const noexcept { + const size_t _size, OutputArrayType* /*_parent*/) const { return new_object(_size); } Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t _size, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { encoder_->key(_name); return new_object(_size); } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* /*_parent*/) const noexcept { + OutputArrayType* /*_parent*/) const { encoder_->null_value(); return OutputVarType{}; } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept { + const std::string_view& _name, OutputObjectType* /*_parent*/) const { encoder_->key(_name); encoder_->null_value(); return OutputVarType{}; } -void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept { +void Writer::end_array(OutputArrayType* /*_arr*/) const { encoder_->end_array(); } -void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept { +void Writer::end_object(OutputObjectType* /*_obj*/) const { encoder_->end_object(); } -Writer::OutputArrayType Writer::new_array(const size_t _size) const noexcept { +Writer::OutputArrayType Writer::new_array(const size_t _size) const { encoder_->begin_array(_size); return OutputArrayType{}; } -Writer::OutputObjectType Writer::new_object(const size_t _size) const noexcept { +Writer::OutputObjectType Writer::new_object(const size_t _size) const { encoder_->begin_object(_size); return OutputObjectType{}; } From 685fb1a430d96b618f63194bd0551486e0a682f4 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 21:15:04 +0100 Subject: [PATCH 14/18] Update capnproto, xml, yaml --- include/rfl/capnproto/Writer.hpp | 78 +++++++++++++-------------- include/rfl/xml/Writer.hpp | 51 +++++++++--------- include/rfl/yaml/Writer.hpp | 44 +++++++-------- src/rfl/capnproto/Writer.cpp | 93 ++++++++++++++++---------------- src/rfl/xml/Writer.cpp | 30 +++++------ src/rfl/yaml/Writer.cpp | 33 ++++++------ 6 files changed, 163 insertions(+), 166 deletions(-) diff --git a/include/rfl/capnproto/Writer.hpp b/include/rfl/capnproto/Writer.hpp index a9a46d055..0eaf4f84b 100644 --- a/include/rfl/capnproto/Writer.hpp +++ b/include/rfl/capnproto/Writer.hpp @@ -10,14 +10,14 @@ #include #include -//#include "../Box.hpp" +// #include "../Box.hpp" #include "../Bytestring.hpp" -//#include "../Ref.hpp" -//#include "../Result.hpp" +// #include "../Ref.hpp" +// #include "../Result.hpp" #include "../Vectorstring.hpp" #include "../always_false.hpp" #include "../internal/is_literal.hpp" -//#include "../internal/ptr_cast.hpp" +// #include "../internal/ptr_cast.hpp" #include "../common.hpp" namespace rfl::capnproto { @@ -57,109 +57,109 @@ class RFL_API Writer { ~Writer(); template - OutputArrayType array_as_root(const T /*_size*/) const noexcept { + OutputArrayType array_as_root(const T /*_size*/) const { static_assert(always_false_v, "In Cap'n Proto, root values must always be structs."); throw std::runtime_error("Unsupported."); } template - OutputMapType map_as_root(const T /*_size*/) const noexcept { + OutputMapType map_as_root(const T /*_size*/) const { static_assert(always_false_v, "In Cap'n Proto, root values must always be structs."); throw std::runtime_error("Unsupported."); } - Writer::OutputObjectType object_as_root(const size_t _size) const noexcept; + Writer::OutputObjectType object_as_root(const size_t _size) const; template - OutputVarType null_as_root() const noexcept { + OutputVarType null_as_root() const { static_assert(always_false_v, "In Cap'n Proto, root values must always be structs."); throw std::runtime_error("Unsupported."); } template - OutputUnionType union_as_root() const noexcept { + OutputUnionType union_as_root() const { static_assert(always_false_v, "In Cap'n Proto, root values must always be structs."); throw std::runtime_error("Unsupported."); } template - OutputVarType value_as_root(const T& /*_var*/) const noexcept { + OutputVarType value_as_root(const T& /*_var*/) const { static_assert(always_false_v, "In Cap'n Proto, root values must always be structs."); throw std::runtime_error("Unsupported."); } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_map(const std::string_view& _name, const size_t _size, - OutputMapType* _parent) const noexcept; + OutputMapType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputArrayType add_array_to_union(const size_t _index, const size_t _size, - OutputUnionType* _parent) const noexcept; + OutputUnionType* _parent) const; OutputMapType add_map_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputMapType add_map_to_map(const std::string_view& _name, const size_t _size, - OutputMapType* _parent) const noexcept; + OutputMapType* _parent) const; OutputMapType add_map_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputMapType add_map_to_union(const size_t _index, const size_t _size, - OutputUnionType* _parent) const noexcept; + OutputUnionType* _parent) const; OutputObjectType add_object_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputObjectType add_object_to_map(const std::string_view& _name, const size_t _size, - OutputMapType* _parent) const noexcept; + OutputMapType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t _size, + OutputObjectType* _parent) const; OutputObjectType add_object_to_union(const size_t _index, const size_t _size, - OutputUnionType* _parent) const noexcept; + OutputUnionType* _parent) const; - OutputUnionType add_union_to_array(OutputArrayType* _parent) const noexcept; + OutputUnionType add_union_to_array(OutputArrayType* _parent) const; OutputUnionType add_union_to_map(const std::string_view& _name, - OutputMapType* _parent) const noexcept; + OutputMapType* _parent) const; OutputUnionType add_union_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputUnionType add_union_to_union(const size_t _index, - OutputUnionType* _parent) const noexcept; + OutputUnionType* _parent) const; - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_map(const std::string_view& _name, - OutputMapType* _parent) const noexcept; + OutputMapType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputVarType add_null_to_union(const size_t _index, - OutputUnionType* _parent) const noexcept; + OutputUnionType* _parent) const; template OutputVarType add_value_to_array(const T& _var, - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { if constexpr (std::is_same, std::string>()) { _parent->val_.set(_parent->ix_++, _var.c_str()); @@ -189,7 +189,7 @@ class RFL_API Writer { template OutputVarType add_value_to_map(const std::string_view& _name, const T& _var, - OutputMapType* _parent) const noexcept { + OutputMapType* _parent) const { auto entries = OutputArrayType{_parent->val_.get("entries").as()}; auto new_entry = add_object_to_array(2, &entries); @@ -200,7 +200,7 @@ class RFL_API Writer { template OutputVarType add_value_to_object(const std::string_view& _name, const T& _var, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { if constexpr (std::is_same, std::string>()) { _parent->val_.set(_name.data(), _var.c_str()); @@ -228,7 +228,7 @@ class RFL_API Writer { template OutputVarType add_value_to_union(const size_t _index, const T& _var, - OutputUnionType* _parent) const noexcept { + OutputUnionType* _parent) const { const auto field = _parent->val_.getSchema().getFields()[_index]; if constexpr (std::is_same, std::string>()) { @@ -256,11 +256,11 @@ class RFL_API Writer { return OutputVarType{}; } - void end_array(OutputArrayType* /*_arr*/) const noexcept {} + void end_array(OutputArrayType* /*_arr*/) const {} - void end_map(OutputMapType* /*_obj*/) const noexcept {} + void end_map(OutputMapType* /*_obj*/) const {} - void end_object(OutputObjectType* /*_obj*/) const noexcept {} + void end_object(OutputObjectType* /*_obj*/) const {} private: capnp::DynamicStruct::Builder* root_; diff --git a/include/rfl/xml/Writer.hpp b/include/rfl/xml/Writer.hpp index 18e0ab0aa..bd20febea 100644 --- a/include/rfl/xml/Writer.hpp +++ b/include/rfl/xml/Writer.hpp @@ -40,60 +40,60 @@ struct RFL_API Writer { ~Writer(); - OutputArrayType array_as_root(const size_t _size) const noexcept; + OutputArrayType array_as_root(const size_t _size) const; - OutputObjectType object_as_root(const size_t _size) const noexcept; + OutputObjectType object_as_root(const size_t _size) const; - OutputVarType null_as_root() const noexcept; + OutputVarType null_as_root() const; template - OutputVarType value_as_root(const T& _var) const noexcept { + OutputVarType value_as_root(const T& _var) const { const auto str = to_string(_var); return value_as_root_impl(str); } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t _size, + OutputObjectType* _parent) const; template OutputVarType add_value_to_array(const T& _var, - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { const auto str = to_string(_var); return add_value_to_array_impl(str, _parent); } template - OutputVarType add_value_to_object( - const std::string_view& _name, const T& _var, OutputObjectType* _parent, - const bool _is_attribute = false) const noexcept { + OutputVarType add_value_to_object(const std::string_view& _name, + const T& _var, OutputObjectType* _parent, + const bool _is_attribute = false) const { const auto str = to_string(_var); return add_value_to_object_impl(_name, str, _parent, _is_attribute); } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; - OutputVarType add_null_to_object( - const std::string_view& _name, OutputObjectType* _parent, - const bool _is_attribute = false) const noexcept; + OutputVarType add_null_to_object(const std::string_view& _name, + OutputObjectType* _parent, + const bool _is_attribute = false) const; - void end_array(OutputArrayType* _arr) const noexcept; + void end_array(OutputArrayType* _arr) const; - void end_object(OutputObjectType* _obj) const noexcept; + void end_object(OutputObjectType* _obj) const; private: template - std::string to_string(const T& _val) const noexcept { + std::string to_string(const T& _val) const { if constexpr (std::is_same, std::string>()) { return _val; } else if constexpr (std::is_same, bool>()) { @@ -106,15 +106,14 @@ struct RFL_API Writer { } } - OutputVarType value_as_root_impl(const std::string& _str) const noexcept; + OutputVarType value_as_root_impl(const std::string& _str) const; - OutputVarType add_value_to_array_impl( - const std::string& _str, OutputArrayType* _parent) const noexcept; + OutputVarType add_value_to_array_impl(const std::string& _str, + OutputArrayType* _parent) const; OutputVarType add_value_to_object_impl( const std::string_view& _name, const std::string& _str, - OutputObjectType* _parent, - const bool _is_attribute = false) const noexcept; + OutputObjectType* _parent, const bool _is_attribute = false) const; public: Ref root_; diff --git a/include/rfl/yaml/Writer.hpp b/include/rfl/yaml/Writer.hpp index 2925e4970..549e6d42f 100644 --- a/include/rfl/yaml/Writer.hpp +++ b/include/rfl/yaml/Writer.hpp @@ -30,57 +30,57 @@ class RFL_API Writer { ~Writer(); - OutputArrayType array_as_root(const size_t _size) const noexcept; + OutputArrayType array_as_root(const size_t _size) const; - OutputObjectType object_as_root(const size_t _size) const noexcept; + OutputObjectType object_as_root(const size_t _size) const; - OutputVarType null_as_root() const noexcept; + OutputVarType null_as_root() const; template - OutputVarType value_as_root(const T& _var) const noexcept { + OutputVarType value_as_root(const T& _var) const { return insert_value(_var); } OutputArrayType add_array_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; OutputArrayType add_array_to_object(const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; OutputObjectType add_object_to_array(const size_t _size, - OutputArrayType* _parent) const noexcept; + OutputArrayType* _parent) const; - OutputObjectType add_object_to_object( - const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept; + OutputObjectType add_object_to_object(const std::string_view& _name, + const size_t _size, + OutputObjectType* _parent) const; template OutputVarType add_value_to_array(const T& _var, - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { return insert_value(_var); } template OutputVarType add_value_to_object(const std::string_view& _name, const T& _var, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { return insert_value(_name, _var); } - OutputVarType add_null_to_array(OutputArrayType* _parent) const noexcept; + OutputVarType add_null_to_array(OutputArrayType* _parent) const; OutputVarType add_null_to_object(const std::string_view& _name, - OutputObjectType* _parent) const noexcept; + OutputObjectType* _parent) const; - void end_array(OutputArrayType* _arr) const noexcept; + void end_array(OutputArrayType* _arr) const; - void end_object(OutputObjectType* _obj) const noexcept; + void end_object(OutputObjectType* _obj) const; private: template OutputVarType insert_value(const std::string_view& _name, - const T& _var) const noexcept { + const T& _var) const { if constexpr (std::is_same, std::string>() || std::is_same, bool>() || std::is_same, @@ -101,7 +101,7 @@ class RFL_API Writer { } template - OutputVarType insert_value(const T& _var) const noexcept { + OutputVarType insert_value(const T& _var) const { if constexpr (std::is_same, std::string>() || std::is_same, bool>() || std::is_same, @@ -119,13 +119,13 @@ class RFL_API Writer { return OutputVarType{}; } - OutputArrayType new_array(const std::string_view& _name) const noexcept; + OutputArrayType new_array(const std::string_view& _name) const; - OutputArrayType new_array() const noexcept; + OutputArrayType new_array() const; - OutputObjectType new_object(const std::string_view& _name) const noexcept; + OutputObjectType new_object(const std::string_view& _name) const; - OutputObjectType new_object() const noexcept; + OutputObjectType new_object() const; public: const Ref out_; diff --git a/src/rfl/capnproto/Writer.cpp b/src/rfl/capnproto/Writer.cpp index ea4fc53a3..9220142e8 100644 --- a/src/rfl/capnproto/Writer.cpp +++ b/src/rfl/capnproto/Writer.cpp @@ -9,10 +9,11 @@ namespace rfl::capnproto { static_assert(parsing::schemaful::IsSchemafulWriter, "This must be a schemaful writer."); - inline unsigned int SafeSizeToUInt(size_t sizeValue) { - if (sizeValue > static_cast(std::numeric_limits::max())) { - throw std::overflow_error("size_t value is too big to fit into an unsigned int."); + if (sizeValue > + static_cast(std::numeric_limits::max())) { + throw std::overflow_error( + "size_t value is too big to fit into an unsigned int."); } return static_cast(sizeValue); } @@ -21,20 +22,20 @@ Writer::Writer(capnp::DynamicStruct::Builder* _root) : root_(_root){}; Writer::~Writer() = default; -Writer::OutputObjectType Writer::object_as_root( - const size_t /*_size*/) const noexcept { +Writer::OutputObjectType Writer::object_as_root(const size_t /*_size*/) const { return OutputObjectType{root_->as()}; } Writer::OutputArrayType Writer::add_array_to_array( - const size_t _size, OutputArrayType* _parent) const noexcept { + const size_t _size, OutputArrayType* _parent) const { return OutputArrayType{ - _parent->val_.init(SafeSizeToUInt(_parent->ix_++), SafeSizeToUInt(_size)).as()}; + _parent->val_.init(SafeSizeToUInt(_parent->ix_++), SafeSizeToUInt(_size)) + .as()}; } -Writer::OutputArrayType Writer::add_array_to_map( - const std::string_view& _name, const size_t _size, - OutputMapType* _parent) const noexcept { +Writer::OutputArrayType Writer::add_array_to_map(const std::string_view& _name, + const size_t _size, + OutputMapType* _parent) const { auto entries = OutputArrayType{ .val_ = _parent->val_.get("entries").as(), .ix_ = _parent->ix_++}; @@ -45,30 +46,29 @@ Writer::OutputArrayType Writer::add_array_to_map( Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept { - return OutputArrayType{ - _parent->val_.init(_name.data(), SafeSizeToUInt(_size)).as()}; + OutputObjectType* _parent) const { + return OutputArrayType{_parent->val_.init(_name.data(), SafeSizeToUInt(_size)) + .as()}; } Writer::OutputArrayType Writer::add_array_to_union( - const size_t _index, const size_t _size, - OutputUnionType* _parent) const noexcept { - - const auto field = _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)]; - return OutputArrayType{ - _parent->val_.init(field, SafeSizeToUInt(_size)).template as()}; + const size_t _index, const size_t _size, OutputUnionType* _parent) const { + const auto field = + _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)]; + return OutputArrayType{_parent->val_.init(field, SafeSizeToUInt(_size)) + .template as()}; } -Writer::OutputMapType Writer::add_map_to_array( - const size_t _size, OutputArrayType* _parent) const noexcept { +Writer::OutputMapType Writer::add_map_to_array(const size_t _size, + OutputArrayType* _parent) const { auto new_map = add_object_to_array(1, _parent); add_array_to_object("entries", _size, &new_map); return OutputMapType{new_map.val_}; } -Writer::OutputMapType Writer::add_map_to_map( - const std::string_view& _name, const size_t _size, - OutputMapType* _parent) const noexcept { +Writer::OutputMapType Writer::add_map_to_map(const std::string_view& _name, + const size_t _size, + OutputMapType* _parent) const { auto new_map = add_object_to_map(_name, 1, _parent); add_array_to_object("entries", _size, &new_map); return OutputMapType{new_map.val_}; @@ -76,29 +76,29 @@ Writer::OutputMapType Writer::add_map_to_map( Writer::OutputMapType Writer::add_map_to_object( const std::string_view& _name, const size_t _size, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { auto new_map = add_object_to_object(_name, 1, _parent); add_array_to_object("entries", _size, &new_map); return OutputMapType{new_map.val_}; } -Writer::OutputMapType Writer::add_map_to_union( - const size_t _index, const size_t _size, - OutputUnionType* _parent) const noexcept { +Writer::OutputMapType Writer::add_map_to_union(const size_t _index, + const size_t _size, + OutputUnionType* _parent) const { auto new_map = add_object_to_union(_index, 1, _parent); add_array_to_object("entries", _size, &new_map); return OutputMapType{new_map.val_}; } Writer::OutputObjectType Writer::add_object_to_array( - const size_t /*_size*/, OutputArrayType* _parent) const noexcept { + const size_t /*_size*/, OutputArrayType* _parent) const { return OutputObjectType{ _parent->val_[SafeSizeToUInt(_parent->ix_++)].as()}; } Writer::OutputObjectType Writer::add_object_to_map( const std::string_view& _name, const size_t _size, - OutputMapType* _parent) const noexcept { + OutputMapType* _parent) const { auto entries = OutputArrayType{ .val_ = _parent->val_.get("entries").as(), .ix_ = _parent->ix_++}; @@ -109,27 +109,28 @@ Writer::OutputObjectType Writer::add_object_to_map( Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { return OutputObjectType{ _parent->val_.get(_name.data()).as()}; } Writer::OutputObjectType Writer::add_object_to_union( const size_t _index, const size_t /*_size*/, - OutputUnionType* _parent) const noexcept { - const auto field = _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)]; + OutputUnionType* _parent) const { + const auto field = + _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)]; return OutputObjectType{ _parent->val_.init(field).template as()}; } Writer::OutputUnionType Writer::add_union_to_array( - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { return OutputUnionType{ _parent->val_[SafeSizeToUInt(_parent->ix_++)].as()}; } -Writer::OutputUnionType Writer::add_union_to_map( - const std::string_view& _name, OutputMapType* _parent) const noexcept { +Writer::OutputUnionType Writer::add_union_to_map(const std::string_view& _name, + OutputMapType* _parent) const { auto entries = OutputArrayType{ .val_ = _parent->val_.get("entries").as(), .ix_ = _parent->ix_++}; @@ -139,26 +140,27 @@ Writer::OutputUnionType Writer::add_union_to_map( } Writer::OutputUnionType Writer::add_union_to_object( - const std::string_view& _name, OutputObjectType* _parent) const noexcept { + const std::string_view& _name, OutputObjectType* _parent) const { return OutputUnionType{ _parent->val_.get(_name.data()).as()}; } Writer::OutputUnionType Writer::add_union_to_union( - const size_t _index, OutputUnionType* _parent) const noexcept { - const auto field = _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)]; + const size_t _index, OutputUnionType* _parent) const { + const auto field = + _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)]; return OutputUnionType{ _parent->val_.init(field).template as()}; } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { _parent->val_.set(SafeSizeToUInt(_parent->ix_++), capnp::VOID); return OutputVarType{}; } -Writer::OutputVarType Writer::add_null_to_map( - const std::string_view& _name, OutputMapType* _parent) const noexcept { +Writer::OutputVarType Writer::add_null_to_map(const std::string_view& _name, + OutputMapType* _parent) const { auto entries = OutputArrayType{ .val_ = _parent->val_.get("entries").as(), .ix_ = _parent->ix_++}; @@ -168,14 +170,15 @@ Writer::OutputVarType Writer::add_null_to_map( } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* _parent) const noexcept { + const std::string_view& _name, OutputObjectType* _parent) const { _parent->val_.set(_name.data(), capnp::VOID); return OutputVarType{}; } Writer::OutputVarType Writer::add_null_to_union( - const size_t _index, OutputUnionType* _parent) const noexcept { - const auto field = _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)]; + const size_t _index, OutputUnionType* _parent) const { + const auto field = + _parent->val_.getSchema().getFields()[SafeSizeToUInt(_index)]; _parent->val_.set(field, capnp::VOID); return OutputVarType{}; } diff --git a/src/rfl/xml/Writer.cpp b/src/rfl/xml/Writer.cpp index f96123520..0ae9d9771 100644 --- a/src/rfl/xml/Writer.cpp +++ b/src/rfl/xml/Writer.cpp @@ -37,28 +37,26 @@ Writer::Writer(const Ref& _root, const std::string& _root_name) Writer::~Writer() = default; -Writer::OutputArrayType Writer::array_as_root( - const size_t /*_size*/) const noexcept { +Writer::OutputArrayType Writer::array_as_root(const size_t /*_size*/) const { auto node_child = Ref::make(root_->append_child(root_name_.c_str())); return OutputArrayType(root_name_, node_child); } -Writer::OutputObjectType Writer::object_as_root( - const size_t /*_size*/) const noexcept { +Writer::OutputObjectType Writer::object_as_root(const size_t /*_size*/) const { auto node_child = Ref::make(root_->append_child(root_name_.c_str())); return OutputObjectType(node_child); } -Writer::OutputVarType Writer::null_as_root() const noexcept { +Writer::OutputVarType Writer::null_as_root() const { auto node_child = Ref::make(root_->append_child(root_name_.c_str())); return OutputVarType(node_child); } Writer::OutputVarType Writer::value_as_root_impl( - const std::string& _str) const noexcept { + const std::string& _str) const { auto node_child = Ref::make(root_->append_child(root_name_.c_str())); node_child->append_child(pugi::node_pcdata).set_value(_str.c_str()); @@ -66,18 +64,18 @@ Writer::OutputVarType Writer::value_as_root_impl( } Writer::OutputArrayType Writer::add_array_to_array( - const size_t /*_size*/, OutputArrayType* _parent) const noexcept { + const size_t /*_size*/, OutputArrayType* _parent) const { return *_parent; } Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { return OutputArrayType(_name, _parent->node_); } Writer::OutputVarType Writer::add_value_to_array_impl( - const std::string& _str, OutputArrayType* _parent) const noexcept { + const std::string& _str, OutputArrayType* _parent) const { auto node_child = Ref::make(_parent->node_->append_child(_parent->name_)); node_child->append_child(pugi::node_pcdata).set_value(_str.c_str()); @@ -86,7 +84,7 @@ Writer::OutputVarType Writer::add_value_to_array_impl( Writer::OutputVarType Writer::add_value_to_object_impl( const std::string_view& _name, const std::string& _str, - OutputObjectType* _parent, const bool _is_attribute) const noexcept { + OutputObjectType* _parent, const bool _is_attribute) const { if (_is_attribute) { _parent->node_->append_attribute(_name) = _str.c_str(); return OutputVarType(_parent->node_); @@ -102,7 +100,7 @@ Writer::OutputVarType Writer::add_value_to_object_impl( } Writer::OutputObjectType Writer::add_object_to_array( - const size_t /*_size*/, OutputArrayType* _parent) const noexcept { + const size_t /*_size*/, OutputArrayType* _parent) const { auto node_child = Ref::make(_parent->node_->append_child(_parent->name_)); return OutputObjectType(node_child); @@ -110,14 +108,14 @@ Writer::OutputObjectType Writer::add_object_to_array( Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* _parent) const noexcept { + OutputObjectType* _parent) const { auto node_child = Ref::make(_parent->node_->append_child(_name)); return OutputObjectType(node_child); } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* _parent) const noexcept { + OutputArrayType* _parent) const { auto node_child = Ref::make(_parent->node_->append_child(_parent->name_)); return OutputVarType(node_child); @@ -125,7 +123,7 @@ Writer::OutputVarType Writer::add_null_to_array( Writer::OutputVarType Writer::add_null_to_object( const std::string_view& _name, OutputObjectType* _parent, - const bool _is_attribute) const noexcept { + const bool _is_attribute) const { if (_is_attribute) { return OutputVarType(_parent->node_); } else if (_name == XML_CONTENT) { @@ -137,8 +135,8 @@ Writer::OutputVarType Writer::add_null_to_object( } } -void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept {} +void Writer::end_array(OutputArrayType* /*_arr*/) const {} -void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept {} +void Writer::end_object(OutputObjectType* /*_obj*/) const {} } // namespace rfl::xml diff --git a/src/rfl/yaml/Writer.cpp b/src/rfl/yaml/Writer.cpp index 3de75c28d..e673e736f 100644 --- a/src/rfl/yaml/Writer.cpp +++ b/src/rfl/yaml/Writer.cpp @@ -6,78 +6,75 @@ Writer::Writer(const Ref& _out) : out_(_out) {} Writer::~Writer() = default; -Writer::OutputArrayType Writer::array_as_root( - const size_t /*_size*/) const noexcept { +Writer::OutputArrayType Writer::array_as_root(const size_t /*_size*/) const { return new_array(); } -Writer::OutputObjectType Writer::object_as_root( - const size_t /*_size*/) const noexcept { +Writer::OutputObjectType Writer::object_as_root(const size_t /*_size*/) const { return new_object(); } -Writer::OutputVarType Writer::null_as_root() const noexcept { +Writer::OutputVarType Writer::null_as_root() const { return insert_value(YAML::Null); } Writer::OutputArrayType Writer::add_array_to_array( - const size_t /*_size*/, OutputArrayType* /*_parent*/) const noexcept { + const size_t /*_size*/, OutputArrayType* /*_parent*/) const { return new_array(); } Writer::OutputArrayType Writer::add_array_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { return new_array(_name); } Writer::OutputObjectType Writer::add_object_to_array( - const size_t /*_size*/, OutputArrayType* /*_parent*/) const noexcept { + const size_t /*_size*/, OutputArrayType* /*_parent*/) const { return new_object(); } Writer::OutputObjectType Writer::add_object_to_object( const std::string_view& _name, const size_t /*_size*/, - OutputObjectType* /*_parent*/) const noexcept { + OutputObjectType* /*_parent*/) const { return new_object(_name); } Writer::OutputVarType Writer::add_null_to_array( - OutputArrayType* /*_parent*/) const noexcept { + OutputArrayType* /*_parent*/) const { return insert_value(YAML::Null); } Writer::OutputVarType Writer::add_null_to_object( - const std::string_view& _name, OutputObjectType* /*_parent*/) const noexcept { + const std::string_view& _name, OutputObjectType* /*_parent*/) const { return insert_value(_name, YAML::Null); } -void Writer::end_array(OutputArrayType* /*_arr*/) const noexcept { +void Writer::end_array(OutputArrayType* /*_arr*/) const { (*out_) << YAML::EndSeq; } -void Writer::end_object(OutputObjectType* /*_obj*/) const noexcept { +void Writer::end_object(OutputObjectType* /*_obj*/) const { (*out_) << YAML::EndMap; } -Writer::OutputArrayType Writer::new_array( - const std::string_view& _name) const noexcept { +Writer::OutputArrayType Writer::new_array(const std::string_view& _name) const { (*out_) << YAML::Key << _name.data() << YAML::Value << YAML::BeginSeq; return OutputArrayType{}; } -Writer::OutputArrayType Writer::new_array() const noexcept { +Writer::OutputArrayType Writer::new_array() const { (*out_) << YAML::BeginSeq; return OutputArrayType{}; } Writer::OutputObjectType Writer::new_object( - const std::string_view& _name) const noexcept { + const std::string_view& _name) const { (*out_) << YAML::Key << _name.data() << YAML::Value << YAML::BeginMap; return OutputObjectType{}; } -Writer::OutputObjectType Writer::new_object() const noexcept { +Writer::OutputObjectType Writer::new_object() const { (*out_) << YAML::BeginMap; return OutputObjectType{}; } From 4e54d7652aed06fe3c52d39c8400cf059b57fff0 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 21:24:08 +0100 Subject: [PATCH 15/18] Added stdexcept --- include/rfl/avro/write.hpp | 1 + include/rfl/bson/Writer.hpp | 1 + include/rfl/bson/write.hpp | 1 + include/rfl/cbor/Writer.hpp | 4 +--- include/rfl/json/Writer.hpp | 1 + include/rfl/json/write.hpp | 1 + include/rfl/msgpack/Writer.hpp | 2 -- 7 files changed, 6 insertions(+), 5 deletions(-) diff --git a/include/rfl/avro/write.hpp b/include/rfl/avro/write.hpp index 90bea3cf1..44f4f979e 100644 --- a/include/rfl/avro/write.hpp +++ b/include/rfl/avro/write.hpp @@ -4,6 +4,7 @@ #include #include +#include #include #include "../parsing/Parent.hpp" diff --git a/include/rfl/bson/Writer.hpp b/include/rfl/bson/Writer.hpp index 15ae39f65..29b1fdb25 100644 --- a/include/rfl/bson/Writer.hpp +++ b/include/rfl/bson/Writer.hpp @@ -4,6 +4,7 @@ #include #include +#include #include #include #include diff --git a/include/rfl/bson/write.hpp b/include/rfl/bson/write.hpp index 1603475ad..1938eb6cb 100644 --- a/include/rfl/bson/write.hpp +++ b/include/rfl/bson/write.hpp @@ -5,6 +5,7 @@ #include #include +#include #include #include "../Processors.hpp" diff --git a/include/rfl/cbor/Writer.hpp b/include/rfl/cbor/Writer.hpp index c6e99f8fb..d509b5a35 100644 --- a/include/rfl/cbor/Writer.hpp +++ b/include/rfl/cbor/Writer.hpp @@ -2,14 +2,12 @@ #define RFL_CBOR_WRITER_HPP_ #include +#include #include #include #include -// #include "../Box.hpp" #include "../Bytestring.hpp" -// #include "../Ref.hpp" -// #include "../Result.hpp" #include "../Vectorstring.hpp" #include "../always_false.hpp" #include "../common.hpp" diff --git a/include/rfl/json/Writer.hpp b/include/rfl/json/Writer.hpp index decf08424..159c0e0ea 100644 --- a/include/rfl/json/Writer.hpp +++ b/include/rfl/json/Writer.hpp @@ -8,6 +8,7 @@ #endif #include +#include #include #include #include diff --git a/include/rfl/json/write.hpp b/include/rfl/json/write.hpp index 0b5696388..e921eb554 100644 --- a/include/rfl/json/write.hpp +++ b/include/rfl/json/write.hpp @@ -9,6 +9,7 @@ #endif #include +#include #include #include "../Processors.hpp" diff --git a/include/rfl/msgpack/Writer.hpp b/include/rfl/msgpack/Writer.hpp index fa7a02253..be199fd80 100644 --- a/include/rfl/msgpack/Writer.hpp +++ b/include/rfl/msgpack/Writer.hpp @@ -3,8 +3,6 @@ #include -#include -#include #include #include #include From c5a6eb617ccb9c0488008886692e43188968dc51 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Sun, 26 Oct 2025 22:03:08 +0100 Subject: [PATCH 16/18] Remove references to Bytestring --- include/rfl/bson/Reader.hpp | 18 ++++-------------- 1 file changed, 4 insertions(+), 14 deletions(-) diff --git a/include/rfl/bson/Reader.hpp b/include/rfl/bson/Reader.hpp index e7d55f1c2..28ae9a519 100644 --- a/include/rfl/bson/Reader.hpp +++ b/include/rfl/bson/Reader.hpp @@ -106,22 +106,12 @@ struct Reader { using VectorType = std::remove_cvref_t; using ValueType = typename VectorType::value_type; if (btype != BSON_TYPE_BINARY) { - if constexpr (std::is_same, rfl::Bytestring>()) { - return error("Could not cast to bytestring."); - } else { - return error("Could not cast to vectorstring."); - } + return error("Could not cast to bytestring."); } if (value.v_binary.subtype != BSON_SUBTYPE_BINARY) { - if constexpr (std::is_same, rfl::Bytestring>()) { - return error( - "The BSON subtype must be a binary in order to read into a " - "bytestring."); - } else { - return error( - "The BSON subtype must be a binary in order to read into a " - "vectorstring."); - } + return error( + "The BSON subtype must be a binary in order to read into a " + "bytestring."); } const auto data = internal::ptr_cast(value.v_binary.data); From 1d1b6bef66326b0ace9614b5888177c69915c7b6 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Mon, 27 Oct 2025 18:47:17 +0100 Subject: [PATCH 17/18] Fixed remaining reference to bytestring --- include/rfl/msgpack/Reader.hpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/include/rfl/msgpack/Reader.hpp b/include/rfl/msgpack/Reader.hpp index 1c4345c48..0b332a15b 100644 --- a/include/rfl/msgpack/Reader.hpp +++ b/include/rfl/msgpack/Reader.hpp @@ -70,11 +70,7 @@ struct Reader { using VectorType = std::remove_cvref_t; using ValueType = typename VectorType::value_type; if (type != MSGPACK_OBJECT_BIN) { - if constexpr (std::is_same, rfl::Bytestring>()) { - return error("Could not cast to bytestring."); - } else { - return error("Could not cast to vectorstring."); - } + return error("Could not cast to bytestring."); } const auto bin = _var.via.bin; const auto data = internal::ptr_cast(bin.ptr); From a3bfd962c8cac22517ce8995405bb5ac3349a3d5 Mon Sep 17 00:00:00 2001 From: "Dr. Patrick Urbanke" Date: Mon, 27 Oct 2025 21:13:03 +0100 Subject: [PATCH 18/18] Added missing checks --- include/rfl/msgpack/Writer.hpp | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/include/rfl/msgpack/Writer.hpp b/include/rfl/msgpack/Writer.hpp index be199fd80..e9377b324 100644 --- a/include/rfl/msgpack/Writer.hpp +++ b/include/rfl/msgpack/Writer.hpp @@ -63,8 +63,14 @@ class RFL_API Writer { template OutputVarType add_value_to_object(const std::string_view& _name, const T& _var, OutputObjectType*) const { - msgpack_pack_str(pk_, _name.size()); - msgpack_pack_str_body(pk_, _name.data(), _name.size()); + auto err = msgpack_pack_str(pk_, _name.size()); + if (err) { + throw std::runtime_error("Could not pack string."); + } + err = msgpack_pack_str_body(pk_, _name.data(), _name.size()); + if (err) { + throw std::runtime_error("Could not pack string body."); + } return new_value(_var); }