type_traits.hpp

#pragma once
 
#include <iosfwd>
#include <tuple>
#include <type_traits>
 
#include <userver/utils/meta.hpp>
 
#include <userver/storages/postgres/detail/is_decl_complete.hpp>
#include <userver/storages/postgres/io/io_fwd.hpp>
#include <userver/storages/postgres/io/traits.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::postgres::io::traits {
 
template <bool Value>
using BoolConstant = std::integral_constant<bool, Value>;
template <std::size_t Value>
using SizeConstant = std::integral_constant<std::size_t, Value>;
 
///@{
/** @name Type mapping traits */
/// @brief Detect if the C++ type is mapped to a Postgres system type.
template <typename T>
struct IsMappedToSystemType : utils::IsDeclComplete<CppToSystemPg<T>> {};
template <typename T>
inline constexpr bool kIsMappedToSystemType = IsMappedToSystemType<T>::value;
 
/// @brief Detect if the C++ type is mapped to a Postgres user type.
template <typename T>
struct IsMappedToUserType : utils::IsDeclComplete<CppToUserPg<T>> {};
template <typename T>
inline constexpr bool kIsMappedToUserType = IsMappedToUserType<T>::value;
 
/// @brief Detect if the C++ type is mapped to a Postgres array type.
template <typename T>
struct IsMappedToArray;
template <typename T>
inline constexpr bool kIsMappedToArray = IsMappedToArray<T>::value;
 
/// @brief Detect if the C++ type is mapped to a Postgres type.
template <typename T, typename = USERVER_NAMESPACE::utils::void_t<>>
struct IsMappedToPg : BoolConstant<kIsMappedToUserType<T> || kIsMappedToSystemType<T> || kIsMappedToArray<T>> {};
template <typename T>
inline constexpr bool kIsMappedToPg = IsMappedToPg<T>::value;
 
/// @brief Mark C++ mapping a special case for disambiguation.
template <typename T, typename = USERVER_NAMESPACE::utils::void_t<>>
struct IsSpecialMapping : std::false_type {};
template <typename T>
inline constexpr bool kIsSpecialMapping = IsSpecialMapping<T>::value;
///@}
 
///@{
/** @name Detect iostream operators */
template <typename T>
using HasOutputOperator = decltype(std::declval<std::ostream&>() << std::declval<T&>());
 
template <typename T>
inline constexpr bool kHasOutputOperator = meta::kIsDetected<HasOutputOperator, T>;
 
template <typename T>
using HasInputOperator = decltype(std::declval<std::istream&>() >> std::declval<T&>());
 
template <typename T>
inline constexpr bool kHasInputOperator = meta::kIsDetected<HasInputOperator, T>;
///@}
 
///@{
/** @name Traits for containers */
/// @brief Mark C++ container type as supported by the driver.
template <typename T>
struct IsCompatibleContainer : std::false_type {};
template <typename T>
inline constexpr bool kIsCompatibleContainer = IsCompatibleContainer<T>::value;
 
template <typename T>
inline constexpr bool kIsFixedSizeContainer = meta::kIsFixedSizeContainer<T>;
/// @}
 
///@{
/// @brief Calculate number of dimensions in C++ container.
template <typename T, typename Enable = USERVER_NAMESPACE::utils::void_t<>>
struct DimensionCount : SizeConstant<0> {};
 
template <typename T>
struct DimensionCount<T, std::enable_if_t<kIsCompatibleContainer<T>>>
    : SizeConstant<1 + DimensionCount<typename T::value_type>::value> {};
template <typename T>
inline constexpr std::size_t kDimensionCount = DimensionCount<T>::value;
///@}
 
///@{
/// @brief Detect type of multidimensional C++ container.
template <typename T>
struct ContainerFinalElement;
 
namespace detail {
 
template <typename T>
struct FinalElementImpl {
    using type = T;
};
 
template <typename T>
struct ContainerFinalElementImpl {
    using type = typename ContainerFinalElement<typename T::value_type>::type;
};
 
}  // namespace detail
 
template <typename T>
struct ContainerFinalElement
    : std::conditional_t<kIsCompatibleContainer<T>, detail::ContainerFinalElementImpl<T>, detail::FinalElementImpl<T>> {
};
 
template <typename T>
using ContainerFinaleElementType = typename ContainerFinalElement<T>::type;
///@}
 
///@{
/** @name IsMappedToArray implementation */
namespace detail {
 
template <typename Container>
constexpr bool EnableContainerMapping() {
    if constexpr (!traits::kIsCompatibleContainer<Container>) {
        return false;
    } else {
        return traits::kIsMappedToPg<typename traits::ContainerFinalElement<Container>::type>;
    }
}
 
}  // namespace detail
 
template <typename T>
struct IsMappedToArray : BoolConstant<detail::EnableContainerMapping<T>()> {};
///@}
 
template <typename T, typename = USERVER_NAMESPACE::utils::void_t<>>
struct CanReserve : std::false_type {};
template <typename T>
struct CanReserve<T, USERVER_NAMESPACE::utils::void_t<decltype(std::declval<T>().reserve(std::declval<std::size_t>()))>>
    : std::true_type {};
template <typename T>
inline constexpr bool kCanReserve = CanReserve<T>::value;
 
template <typename T, typename = USERVER_NAMESPACE::utils::void_t<>>
struct CanResize : std::false_type {};
 
template <typename T>
struct CanResize<T, USERVER_NAMESPACE::utils::void_t<decltype(std::declval<T>().resize(std::declval<std::size_t>()))>>
    : std::true_type {};
template <typename T>
inline constexpr bool kCanResize = CanResize<T>::value;
 
template <typename T, typename = USERVER_NAMESPACE::utils::void_t<>>
struct CanClear : std::false_type {};
 
template <typename T>
struct CanClear<T, USERVER_NAMESPACE::utils::void_t<decltype(std::declval<T>().clear())>> : std::true_type {};
template <typename T>
inline constexpr bool kCanClear = CanClear<T>::value;
 
template <typename T>
auto Inserter(T& container) {
    return meta::Inserter(container);
}
 
template <typename T>
struct RemoveTupleReferences;
 
template <typename... T>
struct RemoveTupleReferences<std::tuple<T...>> {
    using type = std::tuple<std::remove_reference_t<T>...>;
};
 
template <typename T>
struct IsTupleOfRefs : std::false_type {};
template <typename... T>
struct IsTupleOfRefs<std::tuple<T&...>> : std::true_type {};
 
template <typename T>
struct AddTupleConstRef;
 
template <typename... T>
struct AddTupleConstRef<std::tuple<T...>> {
    using type = std::tuple<std::add_const_t<std::add_lvalue_reference_t<std::decay_t<T>>>...>;
};
 
template <typename Tuple>
struct TupleHasParsers;
 
template <typename... T>
struct TupleHasParsers<std::tuple<T...>> : std::bool_constant<(HasParser<std::decay_t<T>>::value && ...)> {};
 
template <typename Tuple>
struct TupleHasFormatters;
 
template <typename... T>
struct TupleHasFormatters<std::tuple<T...>> : std::bool_constant<(HasFormatter<std::decay_t<T>>::value && ...)> {};
 
}  // namespace storages::postgres::io::traits
 
USERVER_NAMESPACE_END