transform_io.hpp

#pragma once
 
#include <userver/storages/postgres/io/buffer_io.hpp>
#include <userver/storages/postgres/io/buffer_io_base.hpp>
#include <userver/storages/postgres/io/field_buffer.hpp>
#include <userver/storages/postgres/io/type_traits.hpp>
#include <userver/storages/postgres/io/user_types.hpp>
 
#include <userver/utils/assert.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres::io {
 
namespace detail {
 
template <typename UserType, typename WireType, typename Converter, bool Categories>
struct TransformParserBase : BufferParserBase<UserType> {
    using BaseType = BufferParserBase<UserType>;
    using BaseType::BaseType;
 
    void operator()(const FieldBuffer& buffer) {
        WireType tmp;
        io::ReadBuffer(buffer, tmp);
        this->value = Converter{}(tmp);
    }
};
 
template <typename UserType, typename WireType, typename Converter>
struct TransformParserBase<UserType, WireType, Converter, true> : BufferParserBase<UserType> {
    using BaseType = BufferParserBase<UserType>;
    using BaseType::BaseType;
 
    void operator()(const FieldBuffer& buffer, const TypeBufferCategory& categories) {
        WireType tmp;
        io::ReadBuffer(buffer, tmp, categories);
        this->value = Converter{}(tmp);
    }
};
 
}  // namespace detail
 
template <typename UserType, typename WireType, typename Converter>
struct TransformParser
    : detail::TransformParserBase<UserType, WireType, Converter, detail::kParserRequiresTypeCategories<WireType>> {
    using BaseType =
        detail::TransformParserBase<UserType, WireType, Converter, detail::kParserRequiresTypeCategories<WireType>>;
    using BaseType::BaseType;
};
 
template <typename UserType, typename WireType, typename Converter>
struct TransformFormatter : detail::BufferFormatterBase<UserType> {
    using BaseType = detail::BufferFormatterBase<UserType>;
    using BaseType::BaseType;
 
    template <typename Buffer>
    void operator()(const UserTypes& types, Buffer& buffer) const {
        if constexpr (traits::IsMappedToSystemType<UserType> && traits::IsMappedToSystemType<WireType>) {
            static_assert(
                CppToPg<UserType>::type_oid == CppToPg<WireType>::type_oid,
                "Database type mismatch in TransformFormatter"
            );
        }
        UASSERT_MSG(
            CppToPg<UserType>::GetOid(types) == CppToPg<WireType>::GetOid(types),
            "Database type mismatch in TransformFormatter"
        );
 
        WireType tmp = Converter{}(this->value);
        io::WriteBuffer(types, buffer, tmp);
    }
};
}  // namespace storages::postgres::io
 
USERVER_NAMESPACE_END