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

weh

Browse source
This commit is contained in:
Mars 2024-06-08 15:53:06 -04:00
parent bd402f57f5
commit 3ea546fe08
Signed by: pupbrained
GPG key ID: 874E22DF2F9DFCB5
166 changed files with 18360 additions and 18199 deletions
Download patch file Download diff file Expand all files Collapse all files

42
include/rfl/cbor/Parser.hpp
View file

@ -12,29 +12,33 @@ namespace rfl {
/// Because of that, we require all of the fields and then set them to
/// nullptr, if necessary.
template <class ProcessorsType, class... FieldTypes>
requires AreReaderAndWriter<cbor::Reader,
cbor::Writer,
NamedTuple<FieldTypes...>>
struct Parser<cbor::Reader,
cbor::Writer,
NamedTuple<FieldTypes...>,
ProcessorsType>
: public NamedTupleParser<cbor::Reader,
cbor::Writer,
/*_ignore_empty_containers=*/false,
/*_all_required=*/true,
ProcessorsType,
FieldTypes...> {};
requires AreReaderAndWriter<
cbor::Reader,
cbor::Writer,
NamedTuple<FieldTypes...>>
struct Parser<
cbor::Reader,
cbor::Writer,
NamedTuple<FieldTypes...>,
ProcessorsType>
: public NamedTupleParser<
cbor::Reader,
cbor::Writer,
/*_ignore_empty_containers=*/false,
/*_all_required=*/true,
ProcessorsType,
FieldTypes...> {};
template <class ProcessorsType, class... Ts>
requires AreReaderAndWriter<cbor::Reader, cbor::Writer, std::tuple<Ts...>>
struct Parser<cbor::Reader, cbor::Writer, std::tuple<Ts...>, ProcessorsType>
: public TupleParser<cbor::Reader,
cbor::Writer,
/*_ignore_empty_containers=*/false,
/*_all_required=*/true,
ProcessorsType,
Ts...> {};
: public TupleParser<
cbor::Reader,
cbor::Writer,
/*_ignore_empty_containers=*/false,
/*_all_required=*/true,
ProcessorsType,
Ts...> {};
} // namespace parsing
} // namespace rfl

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

@ -46,11 +46,12 @@ namespace rfl {
(requires(InputVarType var) { T::from_cbor_obj(var); });
rfl::Result<InputVarType> get_field(
const std::string& _name,
const InputObjectType& _obj) const noexcept {
const std::string& _name,
const InputObjectType& _obj
) const noexcept {
CborValue val;
auto buffer = std::vector<char>();
auto err = cbor_value_enter_container(_obj.val_, &val);
auto buffer = std::vector<char>();
auto err = cbor_value_enter_container(_obj.val_, &val);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
size_t length = 0;
err = cbor_value_get_map_length(_obj.val_, &length);
@ -81,55 +82,56 @@ namespace rfl {
return Error("Could not cast to string.");
}
std::vector<char> buffer;
const auto err = get_string(_var.val_, &buffer);
const auto err = get_string(_var.val_, &buffer);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
return std::string(buffer.data());
} else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {
if (!cbor_value_is_boolean(_var.val_)) {
return rfl::Error("Could not cast to boolean.");
}
bool result = false;
const auto err = cbor_value_get_boolean(_var.val_, &result);
bool result = false;
const auto err = cbor_value_get_boolean(_var.val_, &result);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
return result;
} else if constexpr (std::is_floating_point<std::remove_cvref_t<T>>() ||
std::is_integral<std::remove_cvref_t<T>>()) {
if (cbor_value_is_integer(_var.val_)) {
std::int64_t result = 0;
const auto err = cbor_value_get_int64(_var.val_, &result);
const auto err = cbor_value_get_int64(_var.val_, &result);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
return static_cast<T>(result);
} else if (cbor_value_is_float(_var.val_)) {
float result = 0.0;
const auto err = cbor_value_get_float(_var.val_, &result);
float result = 0.0;
const auto err = cbor_value_get_float(_var.val_, &result);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
return static_cast<T>(result);
} else if (cbor_value_is_double(_var.val_)) {
double result = 0.0;
const auto err = cbor_value_get_double(_var.val_, &result);
double result = 0.0;
const auto err = cbor_value_get_double(_var.val_, &result);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
return static_cast<T>(result);
}
return rfl::Error(
"Could not cast to numeric value. The type must be integral, "
"float "
"or double.");
"or double."
);
} else {
static_assert(rfl::always_false_v<T>, "Unsupported type.");
}
}
rfl::Result<InputArrayType> to_array(
const InputVarType& _var) const noexcept {
rfl::Result<InputArrayType> to_array(const InputVarType& _var
) const noexcept {
if (!cbor_value_is_array(_var.val_)) {
return Error("Could not cast to an array.");
}
return InputArrayType {_var.val_};
}
rfl::Result<InputObjectType> to_object(
const InputVarType& _var) const noexcept {
rfl::Result<InputObjectType> to_object(const InputVarType& _var
) const noexcept {
if (!cbor_value_is_map(_var.val_)) {
return Error("Could not cast to an object.");
}
@ -138,11 +140,12 @@ namespace rfl {
template <class ArrayReader>
std::optional<Error> read_array(
const ArrayReader& _array_reader,
const InputArrayType& _arr) const noexcept {
const ArrayReader& _array_reader,
const InputArrayType& _arr
) const noexcept {
CborValue val;
auto buffer = std::vector<char>();
auto err = cbor_value_enter_container(_arr.val_, &val);
auto buffer = std::vector<char>();
auto err = cbor_value_enter_container(_arr.val_, &val);
if (err != CborNoError && err != CborErrorOutOfMemory) {
return Error(cbor_error_string(err));
}
@ -164,10 +167,11 @@ namespace rfl {
template <class ObjectReader>
std::optional<Error> read_object(
const ObjectReader& _object_reader,
const InputObjectType& _obj) const noexcept {
const ObjectReader& _object_reader,
const InputObjectType& _obj
) const noexcept {
size_t length = 0;
auto err = cbor_value_get_map_length(_obj.val_, &length);
auto err = cbor_value_get_map_length(_obj.val_, &length);
if (err != CborNoError) { return Error(cbor_error_string(err)); }
CborValue val;
@ -190,23 +194,24 @@ namespace rfl {
}
template <class T>
rfl::Result<T> use_custom_constructor(
const InputVarType& _var) const noexcept {
rfl::Result<T> use_custom_constructor(const InputVarType& _var
) const noexcept {
try {
return T::from_cbor_obj(_var);
} catch (std::exception& e) { return rfl::Error(e.what()); }
}
private:
CborError get_string(const CborValue* _ptr,
std::vector<char>* _buffer) const noexcept {
CborError get_string(const CborValue* _ptr, std::vector<char>* _buffer)
const noexcept {
size_t length = 0;
auto err = cbor_value_get_string_length(_ptr, &length);
auto err = cbor_value_get_string_length(_ptr, &length);
if (err != CborNoError && err != CborErrorOutOfMemory) { return err; }
_buffer->resize(length + 1);
(*_buffer)[length] = '\0';
return cbor_value_copy_text_string(_ptr, _buffer->data(), &length,
NULL);
return cbor_value_copy_text_string(
_ptr, _buffer->data(), &length, NULL
);
}
InputVarType to_input_var(CborValue* _ptr) const noexcept {

40
include/rfl/cbor/Writer.hpp
View file

@ -61,29 +61,33 @@ namespace rfl {
}
OutputArrayType add_array_to_array(
const size_t _size,
OutputArrayType* _parent) const noexcept {
const size_t _size,
OutputArrayType* _parent
) const noexcept {
return new_array(_size, _parent->encoder_);
}
OutputArrayType add_array_to_object(
const std::string_view& _name,
const size_t _size,
OutputObjectType* _parent) const noexcept {
const size_t _size,
OutputObjectType* _parent
) const noexcept {
cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
return new_array(_size, _parent->encoder_);
}
OutputObjectType add_object_to_array(
const size_t _size,
OutputArrayType* _parent) const noexcept {
const size_t _size,
OutputArrayType* _parent
) const noexcept {
return new_object(_size, _parent->encoder_);
}
OutputObjectType add_object_to_object(
const std::string_view& _name,
const size_t _size,
OutputObjectType* _parent) const noexcept {
const size_t _size,
OutputObjectType* _parent
) const noexcept {
cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
return new_object(_size, _parent->encoder_);
}
@ -97,8 +101,9 @@ namespace rfl {
template <class T>
OutputVarType add_value_to_object(
const std::string_view& _name,
const T& _var,
OutputObjectType* _parent) const noexcept {
const T& _var,
OutputObjectType* _parent
) const noexcept {
cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
return new_value(_var, _parent->encoder_);
}
@ -110,7 +115,8 @@ namespace rfl {
OutputVarType add_null_to_object(
const std::string_view& _name,
OutputObjectType* _parent) const noexcept {
OutputObjectType* _parent
) const noexcept {
cbor_encode_text_string(_parent->encoder_, _name.data(), _name.size());
cbor_encode_null(_parent->encoder_);
return OutputVarType {};
@ -125,23 +131,23 @@ namespace rfl {
}
private:
OutputArrayType new_array(const size_t _size,
CborEncoder* _parent) const noexcept {
OutputArrayType new_array(const size_t _size, CborEncoder* _parent)
const noexcept {
subencoders_->emplace_back(rfl::Box<CborEncoder>::make());
cbor_encoder_create_array(_parent, subencoders_->back().get(), _size);
return OutputArrayType {subencoders_->back().get(), _parent};
}
OutputObjectType new_object(const size_t _size,
CborEncoder* _parent) const noexcept {
OutputObjectType new_object(const size_t _size, CborEncoder* _parent)
const noexcept {
subencoders_->emplace_back(rfl::Box<CborEncoder>::make());
cbor_encoder_create_map(_parent, subencoders_->back().get(), _size);
return OutputObjectType {subencoders_->back().get(), _parent};
}
template <class T>
OutputVarType new_value(const T& _var,
CborEncoder* _parent) const noexcept {
OutputVarType new_value(const T& _var, CborEncoder* _parent)
const noexcept {
if constexpr (std::is_same<std::remove_cvref_t<T>, std::string>()) {
cbor_encode_text_string(_parent, _var.c_str(), _var.size());
} else if constexpr (std::is_same<std::remove_cvref_t<T>, bool>()) {

13
include/rfl/cbor/read.hpp
View file

@ -25,12 +25,13 @@ namespace rfl {
/// Parses an object from CBOR using reflection.
template <class T, class... Ps>
Result<internal::wrap_in_rfl_array_t<T>> read(const char* _bytes,
const size_t _size) {
Result<internal::wrap_in_rfl_array_t<T>>
read(const char* _bytes, const size_t _size) {
CborParser parser;
CborValue value;
cbor_parser_init(reinterpret_cast<const uint8_t*>(_bytes), _size, 0,
&parser, &value);
CborValue value;
cbor_parser_init(
reinterpret_cast<const uint8_t*>(_bytes), _size, 0, &parser, &value
);
auto doc = InputVarType {&value};
auto result = read<T, Ps...>(doc);
return result;
@ -46,7 +47,7 @@ namespace rfl {
template <class T, class... Ps>
auto read(std::istream& _stream) {
std::istreambuf_iterator<char> begin(_stream), end;
auto bytes = std::vector<char>(begin, end);
auto bytes = std::vector<char>(begin, end);
return read<T, Ps...>(bytes.data(), bytes.size());
}

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

@ -15,23 +15,28 @@ namespace rfl {
namespace cbor {
template <class... Ps>
void write_into_buffer(const auto& _obj,
CborEncoder* _encoder,
std::vector<char>* _buffer) noexcept {
void write_into_buffer(
const auto& _obj,
CborEncoder* _encoder,
std::vector<char>* _buffer
) noexcept {
using T = std::remove_cvref_t<decltype(_obj)>;
using ParentType = parsing::Parent<Writer>;
cbor_encoder_init(_encoder, reinterpret_cast<uint8_t*>(_buffer->data()),
_buffer->size(), 0);
cbor_encoder_init(
_encoder, reinterpret_cast<uint8_t*>(_buffer->data()),
_buffer->size(), 0
);
const auto writer = Writer(_encoder);
Parser<T, Processors<Ps...>>::write(writer, _obj,
typename ParentType::Root {});
Parser<T, Processors<Ps...>>::write(
writer, _obj, typename ParentType::Root {}
);
}
/// Returns CBOR bytes.
template <class... Ps>
std::vector<char> write(const auto& _obj) noexcept {
std::vector<char> buffer(4096);
CborEncoder encoder;
CborEncoder encoder;
write_into_buffer<Ps...>(_obj, &encoder, &buffer);
const auto total_bytes_needed =
buffer.size() + cbor_encoder_get_extra_bytes_needed(&encoder);
@ -40,7 +45,8 @@ namespace rfl {
write_into_buffer<Ps...>(_obj, &encoder, &buffer);
}
const auto length = cbor_encoder_get_buffer_size(
&encoder, reinterpret_cast<uint8_t*>(buffer.data()));
&encoder, reinterpret_cast<uint8_t*>(buffer.data())
);
buffer.resize(length);
return buffer;
}