traits.hpp

#pragma once
 
#include <limits>
#include <string>
#include <type_traits>
#include <unordered_map>
 
#include <userver/storages/postgres/detail/is_decl_complete.hpp>
#include <userver/storages/postgres/io/pg_types.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres {
 
class UserTypes;
 
namespace io {
 
/// Category of buffer contents.
///
/// Applied to binary parsers and deduced from field's data type.
enum class BufferCategory {
    kKeepCategory = -1,  //!< kKeepCategory keep current buffer category
    kNoParser = 0,       //!< kNoParser the data type doesn't have a parser defined
    kVoid,               //!< kVoid there won't be a buffer for this field, but the category is
                         //!< required for correctly handling void results
    kPlainBuffer,        //!< kPlainBuffer the buffer is a single plain value
    kArrayBuffer,        //!< kArrayBuffer the buffer contains an array of values
    kCompositeBuffer,    //!< kCompositeBuffer the buffer contains a user-defined
                         //!< composite type
    kRangeBuffer         //!< kRangeBuffer the buffer contains a range type
};
 
std::string_view ToString(BufferCategory);
 
template <BufferCategory Category>
using BufferCategoryConstant = std::integral_constant<BufferCategory, Category>;
 
using TypeBufferCategory = std::unordered_map<Oid, BufferCategory>;
 
BufferCategory GetTypeBufferCategory(const TypeBufferCategory&, Oid);
 
struct BufferCategoryHash {
    using IntegerType = std::underlying_type_t<BufferCategory>;
    std::size_t operator()(BufferCategory val) const { return std::hash<IntegerType>{}(static_cast<IntegerType>(val)); }
};
 
inline constexpr int kPgBinaryDataFormat = 1;
 
/// Fields that are null are denoted by specifying their length == -1
inline constexpr Integer kPgNullBufferSize = -1;
 
struct FieldBuffer {
    static constexpr std::size_t npos = std::numeric_limits<std::size_t>::max();
 
    bool is_null = false;
    BufferCategory category = BufferCategory::kPlainBuffer;
    std::size_t length = 0;
    const std::uint8_t* buffer = nullptr;
 
    std::string ToString() const { return {reinterpret_cast<const char*>(buffer), length}; }
    constexpr FieldBuffer GetSubBuffer(
        std::size_t offset,
        std::size_t size = npos,
        BufferCategory cat = BufferCategory::kKeepCategory
    ) const;
 
    template <typename T>
    std::size_t Read(T&& value, BufferCategory cat = BufferCategory::kKeepCategory, std::size_t length = sizeof(T));
    template <typename T>
    std::size_t Read(
        T&& value,
        const TypeBufferCategory& categories,
        std::size_t length = sizeof(T),
        BufferCategory cat = BufferCategory::kKeepCategory
    );
 
    // Read 'raw' postgres buffer - first read the size, then read the value
    template <typename T>
    std::size_t ReadRaw(
        T&& value,
        const TypeBufferCategory& categories,
        BufferCategory cat = BufferCategory::kKeepCategory
    );
};
 
/// @brief Primary template for Postgre buffer parser.
/// Specialisations should provide call operators that parse FieldBuffer.
template <typename T>
struct BufferParser;
 
/// @brief Primary template for Postgre buffer formatter
/// Specialisations should provide call operators that write to a buffer.
template <typename T>
struct BufferFormatter;
 
namespace traits {
 
/// Customisation point for parsers
template <typename T>
struct Input {
    using type = BufferParser<T>;
};
 
/// Customisation point for formatters
template <typename T>
struct Output {
    using type = BufferFormatter<T>;
};
 
/// @brief A default deducer of parsers/formatters for a type/data format.
/// Can be specialised for a type/format pair providing custom
/// parsers/formatters.
template <typename T>
struct IO {
    using ParserType = typename Input<T>::type;
    using FormatterType = typename Output<T>::type;
};
 
/// @brief Concept to detect if a type has a parser.
template <typename T>
concept HasParser = utils::IsDeclComplete<typename IO<T>::ParserType>::value;
 
/// @brief Concept to detect if a type has a formatter.
template <typename T>
concept HasFormatter = utils::IsDeclComplete<typename IO<T>::FormatterType>::value;
 
template <typename T>
constexpr bool CheckParser() {
    static_assert(
        HasParser<T> || std::is_enum_v<T>,
        "Type doesn't have a parser. Probably you forgot to include "
        "file with parser or to define your own. Please see page "
        "`uPg: Supported data types` for more information"
    );
 
    static_assert(
        HasParser<T> || !std::is_enum_v<T>,
        "Type doesn't have a parser. Probably you forgot to include "
        "file with parser, to define your own or to specialize "
        "`storages::postgres::io::traits::CanUseEnumAsStrongTypedef`. "
        "See page `uPg: Supported data types` for more information"
    );
 
    return true;
}
 
template <typename T>
constexpr void CheckFormatter() {
    static_assert(
        HasFormatter<T> || std::is_enum_v<T>,
        "Type doesn't have a formatter. Probably you forgot to include "
        "file with formatter or to define your own.  Please see page "
        "`uPg: Supported data types` for more information"
    );
 
    static_assert(
        HasFormatter<T> || !std::is_enum_v<T>,
        "Type doesn't have a formatter. Probably you forgot to include "
        "file with formatter, to define your own or to specialize "
        "`storages::postgres::io::traits::CanUseEnumAsStrongTypedef`. "
        "See page `uPg: Supported data types` for more information"
    );
}
 
/// Buffer category for parser
template <typename T>
struct ParserBufferCategory : BufferCategoryConstant<BufferCategory::kPlainBuffer> {};
template <typename T>
using ParserBufferCategoryType = typename ParserBufferCategory<T>::type;
template <typename T>
inline constexpr BufferCategory kParserBufferCategory = ParserBufferCategory<T>::value;
 
//@{
/** @name Buffer category for a type */
namespace detail {
template <typename T>
constexpr auto DetectBufferCategory() {
    if constexpr (HasParser<T>) {
        return ParserBufferCategoryType<typename IO<T>::ParserType>{};
    } else {
        return BufferCategoryConstant<BufferCategory::kNoParser>{};
    }
}
}  // namespace detail
template <typename T>
struct TypeBufferCategory : decltype(detail::DetectBufferCategory<T>()) {};
template <typename T>
inline constexpr BufferCategory kTypeBufferCategory = TypeBufferCategory<T>::value;
//@}
 
namespace detail {
 
template <typename T>
concept CustomParserDefined = utils::IsDeclComplete<BufferParser<T>>::value;
 
template <typename T>
concept CustomFormatterDefined = utils::IsDeclComplete<BufferFormatter<T>>::value;
 
}  // namespace detail
 
}  // namespace traits
 
}  // namespace io
}  // namespace storages::postgres
 
USERVER_NAMESPACE_END