enum_types.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/storages/postgres/io/enum_types.hpp
/// @brief Enum I/O support
/// @ingroup userver_postgres_parse_and_format
 
#include <string_view>
#include <unordered_map>
 
#include <userver/storages/postgres/io/buffer_io.hpp>
#include <userver/storages/postgres/io/buffer_io_base.hpp>
#include <userver/storages/postgres/io/pg_types.hpp>
#include <userver/storages/postgres/io/transform_io.hpp>
#include <userver/storages/postgres/io/type_mapping.hpp>
#include <userver/storages/postgres/io/user_types.hpp>
#include <userver/utils/trivial_map_fwd.hpp>
 
#include <userver/storages/postgres/detail/string_hash.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres::io {
 
namespace detail {
 
/// Enumerator literal value holder
template <typename Enum>
struct Enumerator {
    Enum enumerator;
    std::string_view literal;
 
    constexpr Enumerator(Enum en, std::string_view lit)
        : enumerator{en},
          literal{lit}
    {}
};
 
}  // namespace detail
 
/// Optional base template for providing type aliases for defining enumeration
/// mapping.
template <typename Enum>
struct EnumMappingBase {
    static_assert(std::is_enum<Enum>(), "Type must be an enumeration");
 
    /// @brief Type alias for the enumeration.
    ///
    /// As the mapping must be specialized in `storages::postgres::io` namespace,
    /// the enumerator value can be quite a long name. This type alias is a
    /// shortcut to the enumeration type.
    using EnumType = Enum;
 
    /// Type alias for enumerator literal value holder
    using Enumerator = detail::Enumerator<Enum>;
 
    /// @brief Type alias for enumerator-literal mapping.
    ///
    /// See @ref pg_enum
    using EnumeratorList = const std::initializer_list<Enumerator>;
};
 
/// Helper for enumerators that use `Parse` and `ToString` functions for
/// conversions, mostly for autogenerated enums from chaotic.
///
/// A generated enum:
/// @snippet storages/postgres/tests/enums_pgtest.cpp autogenerated enum type postgres
/// can be registered in the following way
/// @snippet storages/postgres/tests/enums_pgtest.cpp autogenerated enum registration postgres
///
/// After that the enum is mapped to the PostgreSQL type that can be created in the following way:
/// @snippet storages/postgres/tests/enums_pgtest.cpp User enum type postgres
/// Use it as usual:
/// @snippet storages/postgres/tests/enums_pgtest.cpp autogenerated enum usage postgres
struct Codegen {};
 
namespace detail {
 
template <typename Enum>
struct Enumerators {
    static_assert(std::is_enum<Enum>(), "Type must be an enumeration");
    static_assert(
        requires { CppToUserPg<Enum>::enumerators; },
        "CppToUserPg for an enumeration must contain a static `enumerators` member of `utils::TrivialBiMap` type or "
        "`storages::postgres::io::detail::Enumerator[]`."
    );
    using Type = decltype(CppToUserPg<Enum>::enumerators);
};
 
template <typename Enum, typename = typename Enumerators<Enum>::Type>
class EnumerationMap;
 
template <typename Enum, typename T>
class EnumerationMap {
    using StringType = std::string_view;
    using EnumType = Enum;
    using MappingType = CppToUserPg<EnumType>;
    using EnumeratorType = Enumerator<EnumType>;
 
    struct EnumHash {
        std::size_t operator()(EnumType v) const {
            using underlying_type = std::underlying_type_t<EnumType>;
            using hasher = std::hash<underlying_type>;
            return hasher{}(static_cast<underlying_type>(v));
        }
    };
 
    using EnumToString = std::unordered_map<EnumType, StringType, EnumHash>;
    using StringToEnum = std::unordered_map<StringType, EnumType, utils::StringViewHash>;
    using MapsPair = std::pair<EnumToString, StringToEnum>;
 
    static MapsPair MapLiterals() {
        MapsPair maps;
        for (const auto& enumerator : enumerators) {
            maps.first.insert(std::make_pair(enumerator.enumerator, enumerator.literal));
            maps.second.insert(std::make_pair(enumerator.literal, enumerator.enumerator));
        }
        return maps;
    }
    static const MapsPair& GetMaps() {
        static auto maps = MapLiterals();
        return maps;
    }
    static const EnumToString& EnumeratorMap() { return GetMaps().first; }
    static const StringToEnum& LiteralMap() { return GetMaps().second; }
 
public:
    static constexpr const auto& enumerators = MappingType::enumerators;
    static constexpr std::size_t size = std::size(enumerators);
    static EnumType GetEnumerator(StringType literal) {
        static const auto& map = LiteralMap();
        if (auto f = map.find(literal); f != map.end()) {
            return f->second;
        }
        throw InvalidEnumerationLiteral{compiler::GetTypeName<EnumType>(), std::string{literal.data(), literal.size()}};
    }
    static StringType GetLiteral(EnumType enumerator) {
        static const auto& map = EnumeratorMap();
        if (auto f = map.find(enumerator); f != map.end()) {
            return f->second;
        }
        throw InvalidEnumerationValue{enumerator};
    }
};
 
template <typename Enum, typename Func>
class EnumerationMap<Enum, const USERVER_NAMESPACE::utils::TrivialBiMap<Func>> {
    using StringType = std::string_view;
    using EnumType = Enum;
    using MappingType = CppToUserPg<EnumType>;
 
public:
    static constexpr const auto& enumerators = MappingType::enumerators;
    static constexpr std::size_t size = enumerators.size();
    static constexpr EnumType GetEnumerator(StringType literal) {
        auto enumerator = enumerators.TryFind(literal);
        if (enumerator.has_value()) {
            return *enumerator;
        }
        throw InvalidEnumerationLiteral{compiler::GetTypeName<EnumType>(), std::string{literal.data(), literal.size()}};
    }
    static constexpr StringType GetLiteral(EnumType enumerator) {
        auto literal = enumerators.TryFind(enumerator);
        if (literal.has_value()) {
            return *literal;
        }
        throw InvalidEnumerationValue{enumerator};
    }
};
 
template <typename Enum>
class EnumerationMap<Enum, const Codegen> {
    using EnumType = Enum;
    using MappingType = CppToUserPg<EnumType>;
 
public:
    static EnumType GetEnumerator(std::string_view literal) { return Parse(literal, formats::parse::To<Enum>{}); }
    static std::string GetLiteral(EnumType enumerator) { return ToString(enumerator); }
};
 
template <typename Enum>
struct EnumParser : BufferParserBase<Enum> {
    using BaseType = BufferParserBase<Enum>;
    using EnumMap = EnumerationMap<Enum>;
 
    using BaseType::BaseType;
 
    void operator()(const FieldBuffer& buffer) {
        std::string_view literal;
        io::ReadBuffer(buffer, literal);
        this->value = EnumMap::GetEnumerator(literal);
    }
};
 
template <typename Enum>
struct EnumFormatter : BufferFormatterBase<Enum> {
    using BaseType = BufferFormatterBase<Enum>;
    using EnumMap = EnumerationMap<Enum>;
 
    using BaseType::BaseType;
 
    template <typename Buffer>
    void operator()(const UserTypes& types, Buffer& buffer) const {
        auto literal = EnumMap::GetLiteral(this->value);
        io::WriteBuffer(types, buffer, literal);
    }
};
 
template <typename Enum>
struct EnumConverter {
    using PostgresType = std::string;
    using UserType = Enum;
 
    Enum operator()(const PostgresType& db_data) const { return Parse(db_data, formats::parse::To<Enum>()); }
 
    PostgresType operator()(const Enum& user_data) const { return ToString(user_data); }
};
 
template <typename Enum>
concept HasParse = requires(std::string_view sw) { Parse(sw, formats::parse::To<Enum>{}); };
 
template <typename Enum>
concept HasToString = requires(Enum e) { ToString(e); };
 
}  // namespace detail
 
namespace traits {
 
template <typename T>
struct Input<T, std::enable_if_t<std::is_enum_v<T> && !detail::CustomParserDefined<T> && IsMappedToUserType<T>>> {
    using type = io::detail::EnumParser<T>;
};
 
template <typename T>
struct ParserBufferCategory<io::detail::EnumParser<T>>
    : std::integral_constant<BufferCategory, BufferCategory::kPlainBuffer> {};
 
template <typename T>
struct Output<T, std::enable_if_t<std::is_enum_v<T> && !detail::CustomFormatterDefined<T> && IsMappedToUserType<T>>> {
    using type = io::detail::EnumFormatter<T>;
};
 
// Specialization for enum parsing using ToString function
// Allows C++ enums to be stored as PostgreSQL text when they have ToString support
// but are not mapped to a specific PostgreSQL enum type via CppToUserPg
template <typename Enum>
struct Input<
    Enum,
    std::enable_if_t<
        std::is_enum_v<Enum> && !detail::CustomParserDefined<Enum> && !IsMappedToUserType<Enum> &&
        storages::postgres::io::detail::HasToString<Enum>>> {
    using type = TransformParser<Enum, std::string, storages::postgres::io::detail::EnumConverter<Enum>>;
};
 
// Specialization for enum formatting using Parse functions
// Allows C++ enums to be converted from PostgreSQL text when they have Parse support
// but are not mapped to a specific PostgreSQL enum type via CppToUserPg
template <typename Enum>
struct Output<
    Enum,
    std::enable_if_t<
        std::is_enum_v<Enum> && !detail::CustomFormatterDefined<Enum> && !IsMappedToUserType<Enum> &&
        storages::postgres::io::detail::HasParse<Enum>>> {
    using type = TransformFormatter<Enum, std::string, storages::postgres::io::detail::EnumConverter<Enum>>;
};
 
}  // namespace traits
 
}  // namespace storages::postgres::io
 
USERVER_NAMESPACE_END