workspace/conan/dev_essential/1.4.3/dw/stable/package/aef85909f792a5a628750d25016a24323084963f/include/ddl/serialization/serialization.h

Go to the documentation of this file.

 
#ifndef DDL_SERIALIZER_CLASS_HEADER
#define DDL_SERIALIZER_CLASS_HEADER
 
#include <a_util/result.h>
#include <ddl/codec/codec.h>
#include <ddl/utilities/std_to_string.h>
 
#include <assert.h>
 
namespace ddl {
namespace codec {
 
_MAKE_RESULT(-3, ERR_AUTIL_UNEXPECTED);
 
enum class TransformOption : uint32_t
{ 
    by_memory = 0,
    by_value = 1
};
 
template <typename DECODER, typename ENCODER>
a_util::result::Result transform(const DECODER& decoder,
                                 ENCODER& encoder,
                                 const TransformOption transform_option)
{
    size_t current_element_count = 0;
    std::function<void(const typename DECODER::Element& element)> transform_value;
    if (transform_option == TransformOption::by_memory) {
        transform_value = std::function<void(const typename DECODER::Element& element)>(
            [&current_element_count, &encoder](const typename DECODER::Element& element) {
                uint64_t value_pointer = {}; // this is the max possible size of a data type at the
                                             // moment! Usertypes are not allowed to be greater!
                element.getRawValue(&value_pointer, sizeof(value_pointer));
                encoder.setElementRawValue(encoder.resolve(current_element_count++),
                                           &value_pointer,
                                           sizeof(value_pointer));
            });
    }
    else if (transform_option == TransformOption::by_value) {
        transform_value = std::function<void(const typename DECODER::Element& element)>(
            [&current_element_count, &encoder](const typename DECODER::Element& element) {
                encoder.setElementVariantValue(encoder.resolve(current_element_count++),
                                               element.getVariantValue());
            });
    }
    else {
        RETURN_ERROR_DESCRIPTION(ERR_AUTIL_UNEXPECTED,
                                 std::string("Invalid transform_option given: " +
                                 std::to_string(static_cast<uint32_t>(transform_option))).c_str());
    }
 
    try {
        forEachLeafElement(decoder.getElements(),
            [&transform_value, &encoder](const auto& element) { transform_value(element); });
    }
    catch (const std::exception& oException) {
        RETURN_ERROR_DESCRIPTION(ERR_AUTIL_UNEXPECTED, oException.what());
    }
    return {};
}
 
template <typename DECODER, typename ENCODER>
a_util::result::Result transform(const DECODER& decoder, ENCODER& encoder)
{
    return transform<DECODER, ENCODER>(decoder, encoder, TransformOption::by_value);
}
 
a_util::result::Result transformToBuffer(const codec::Decoder& decoder,
                                         a_util::memory::MemoryBuffer& buffer,
                                         bool zero = false);
 
} // namespace codec
} // namespace ddl
 
#include <ddl/serialization/serialization_legacy.h>
 
#endif // DDL_SERIALIZER_CLASS_HEADER