type_traits.h

#pragma once
 
#include <ozo/detail/float.h>
#include <ozo/core/strong_typedef.h>
#include <ozo/core/nullable.h>
#include <ozo/core/unwrap.h>
#include <ozo/core/concept.h>
#include <ozo/optional.h>
 
#include <libpq-fe.h>
 
#include <boost/hana/at_key.hpp>
#include <boost/hana/insert.hpp>
#include <boost/hana/string.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/type.hpp>
#include <boost/hana/not_equal.hpp>
 
#include <memory>
#include <string>
#include <string_view>
#include <vector>
#include <type_traits>
 
namespace ozo {
 
namespace hana = boost::hana;
using namespace hana::literals;
 
namespace fusion = boost::fusion;
using oid_t = ::Oid;
 
template <oid_t Oid>
struct oid_constant : std::integral_constant<oid_t, Oid> {};
 
using null_oid_t = oid_constant<0>;
 
inline constexpr null_oid_t null_oid;
 
template <typename T>
struct is_array : std::false_type {};
 
template <typename T>
inline constexpr auto Array = is_array<std::decay_t<T>>::value;
 
namespace definitions {
template <typename T>
struct type;
 
template <typename T>
struct array;
} // namespace definitions
 
namespace detail {
 
template <typename Traits, typename = std::void_t<>>
struct is_type_traits_defined : std::false_type {};
 
template <typename T>
struct is_type_traits_defined<T, Require<
    !std::is_void_v<typename T::name>
>> : std::true_type {};
 
template <typename T>
inline auto get_type_traits(const T&) {
    using type = unwrap_type<T>;
    if constexpr (Array<type>) {
        using value_type = unwrap_type<typename type::value_type>;
        if constexpr (is_type_traits_defined<definitions::array<value_type>>::value) {
            return definitions::array<value_type>{};
        } else {
            return;
        }
    } else {
        if constexpr (is_type_traits_defined<definitions::type<type>>::value) {
            return definitions::type<type>{};
        } else {
            return;
        }
    }
}
 
} // namespace detail
 
#ifdef OZO_DOCUMENTATION
template <typename T>
struct type_traits {
    using name = <implementation defined>; 
    using oid = <implementation defined>; 
    using size = <implementation defined>; 
};
#endif
 
template <typename T>
using type_traits = decltype(detail::get_type_traits(std::declval<T>()));
 
template <typename T>
inline constexpr auto HasDefinition = !std::is_void_v<type_traits<T>>;
 
template <typename T>
struct is_composite : std::bool_constant<
    HanaStruct<T> || FusionAdaptedStruct<T>
> {};
 
template <typename T>
inline constexpr auto Composite = is_composite<std::decay_t<T>>::value;
 
using size_type = std::int32_t;
 
template <size_type n>
struct size_constant : std::integral_constant<size_type, n> {};
 
inline constexpr size_constant<-1> null_state_size;
 
template <size_type n>
using bytes = size_constant<n>;
struct dynamic_size : size_constant<-1> {};
 
template <typename T, typename = std::void_t<>>
struct is_built_in : std::false_type {};
 
template <typename T>
struct is_built_in<T, std::enable_if_t<
    !std::is_void_v<typename type_traits<T>::oid>>
> : std::true_type {};
 
template <typename T>
inline constexpr bool BuiltIn = is_built_in<std::decay_t<T>>::value;
 
template <typename T>
struct is_dynamic_size : std::is_same<typename type_traits<T>::size, dynamic_size> {};
 
template <typename T>
inline constexpr auto DynamicSize = is_dynamic_size<std::decay_t<T>>::value;
 
template <typename T>
inline constexpr auto StaticSize = !DynamicSize<T>;
 
template <typename T>
constexpr auto type_name() noexcept {
    static_assert(!std::is_void_v<type_traits<T>>,
        "no type_traits found for the type");
    constexpr auto name = typename type_traits<T>::name{};
    constexpr char const* retval = hana::to<char const*>(name);
    return retval;
}
 
template <typename T>
constexpr auto type_name(const T&) noexcept {return type_name<T>();}
 
namespace detail {
 
template <typename Name, typename Oid = void, typename Size = dynamic_size>
struct type_definition {
    using name = Name;
    using oid = Oid;
    using size = Size;
};
 
template <typename Type, typename Oid>
using array_definition = type_definition<
    decltype(typename type_traits<Type>::name{} + "[]"_s),
    Oid
>;
 
} // namespace detail
} // namespace ozo
 
#define OZO_PG_DEFINE_TYPE_(Type, Name, OidType, Size) \
    namespace ozo::definitions {\
    template <>\
    struct type<Type> : detail::type_definition<decltype(Name##_s), OidType, Size>{\
        static_assert(std::is_same_v<Size, dynamic_size>\
            || Size::value == null_state_size\
            || static_cast<size_type>(sizeof(Type)) == Size::value,\
            #Type " type size does not match to declared size");\
    };\
    }
 
#define OZO_PG_DEFINE_TYPE(Type, Name, Oid, Size) \
    OZO_PG_DEFINE_TYPE_(Type, Name, oid_constant<Oid>, Size)
 
#define OZO_PG_DEFINE_TYPE_ARRAY_(Type, OidType) \
    namespace ozo::definitions {\
    template <>\
    struct array<Type> : detail::array_definition<Type, OidType>{};\
    }
 
#define OZO_PG_DEFINE_TYPE_AND_ARRAY_(Type, Name, OidType, ArrayOidType, Size) \
    OZO_PG_DEFINE_TYPE_(Type, Name, OidType, Size) \
    OZO_PG_DEFINE_TYPE_ARRAY_(Type, ArrayOidType)
 
#ifdef OZO_DOCUMENTATION
#define OZO_PG_DEFINE_TYPE_AND_ARRAY(Type, Name, Oid, ArrayOid, Size)
#else
#define OZO_PG_DEFINE_TYPE_AND_ARRAY(Type, Name, Oid, ArrayOid, Size) \
    OZO_PG_DEFINE_TYPE_AND_ARRAY_(Type, Name, oid_constant<Oid>, oid_constant<ArrayOid>, Size)
#endif
 
#ifdef OZO_DOCUMENTATION
#define OZO_PG_DEFINE_CUSTOM_TYPE(Type, Name [, Size])
#else
#define OZO_PG_DEFINE_CUSTOM_TYPE_IMPL_3(Type, Name, Size) \
    OZO_PG_DEFINE_TYPE_AND_ARRAY_(Type, Name, void, void, Size)
 
#define OZO_PG_DEFINE_CUSTOM_TYPE_IMPL_2(Type, Name) \
    OZO_PG_DEFINE_CUSTOM_TYPE_IMPL_3(Type, Name, dynamic_size)
 
#define OZO_PG_DEFINE_CUSTOM_TYPE(...)\
    BOOST_PP_OVERLOAD(OZO_PG_DEFINE_CUSTOM_TYPE_IMPL_,__VA_ARGS__)(__VA_ARGS__)
#endif
 
namespace ozo {
 
namespace detail {
 
template <typename ... T>
constexpr decltype(auto) register_types() noexcept {
    return hana::make_map(
        hana::make_pair(hana::type_c<T>, null_oid()) ...
    );
}
 
} // namespace detail
 
template <typename ...Ts>
struct oid_map_t {
    using impl_type = decltype(detail::register_types<Ts...>());
 
    impl_type impl;
};
 
 
template <typename T>
struct is_oid_map : std::false_type {};
 
template <typename ...Ts>
struct is_oid_map<oid_map_t<Ts...>> : std::true_type {};
 
template <typename T>
inline constexpr auto OidMap = is_oid_map<std::decay_t<T>>::value;
 
template <typename ...Ts>
constexpr oid_map_t<Ts...> register_types() noexcept {
    return {};
}
 
using empty_oid_map = std::decay_t<decltype(register_types<>())>;
 
inline constexpr empty_oid_map empty_oid_map_c;
 
template <typename T, typename ...Ts>
inline void set_type_oid(oid_map_t<Ts...>& map, oid_t oid) noexcept {
    static_assert(!is_built_in<T>::value, "type must not be built-in");
    map.impl[hana::type_c<T>] = oid;
}
 
#ifdef OZO_DOCUMENTATION
template <typename T, typename OidMap>
oid_t type_oid(const OidMap& map) noexcept;
#else
template <typename T, typename ...Ts>
inline auto type_oid(const oid_map_t<Ts...>& map) noexcept
        -> Require<!BuiltIn<T>, oid_t> {
    constexpr auto key = hana::type_c<unwrap_type<T>>;
    static_assert(decltype(hana::find(map.impl, key) != hana::nothing)::value,
        "type OID for T can not be found in the OidMap, it should be registered via register_type()");
    return map.impl[key];
}
 
template <typename T, typename OidMap>
constexpr auto type_oid(const OidMap&) noexcept
        -> Require<BuiltIn<T>, oid_t> {
    static_assert(ozo::OidMap<OidMap>, "map should model OidMap concept");
    return typename type_traits<T>::oid();
}
#endif
 
#ifdef OZO_DOCUMENTATION
template <typename T, typename OidMap>
oid_t type_oid(const OidMap& map, const T& v) noexcept
#else
template <typename T, typename OidMap>
inline auto type_oid(const OidMap& map, const T&) noexcept{
    static_assert(ozo::OidMap<OidMap>, "map should model OidMap concept");
    return type_oid<std::decay_t<T>>(map);
}
#endif
 
template <typename T, typename OidMap>
inline bool accepts_oid(const OidMap& map, oid_t oid) noexcept {
    static_assert(ozo::OidMap<OidMap>, "map should model OidMap concept");
    return type_oid<T>(map) == oid;
}
 
template <typename T, typename OidMap>
inline bool accepts_oid(const OidMap& map, const T& , oid_t oid) noexcept {
    return accepts_oid<std::decay_t<T>>(map, oid);
}
 
template <typename ...Ts>
inline constexpr bool empty(const oid_map_t<Ts...>& map) noexcept {
    return hana::length(map.impl) == hana::size_c<0>;
}
 
} // namespace ozo