size_of.h

#pragma once
 
#include <ozo/type_traits.h>
 
namespace ozo {
 
template <typename T, typename = std::void_t<>>
struct size_of_impl;
 
namespace detail {
 
template <typename T, typename = std::void_t<>>
struct size_of_default_impl {
    static constexpr auto apply(const T&) noexcept {
        return typename type_traits<T>::size{};
    }
};
 
template <typename T>
struct size_of_default_impl<T, Require<DynamicSize<T>>> {
    static constexpr auto apply(const T& v) noexcept(noexcept(std::size(v))){
        return std::size(v) * sizeof(decltype(*std::begin(v)));
    }
};
 
template <typename T, typename = std::void_t<>>
struct size_of_impl_dispatcher { using type = size_of_impl<std::decay_t<T>>; };
 
template <typename T, typename Tag>
struct size_of_impl_dispatcher<strong_typedef_wrapper<T, Tag>> { using type = size_of_impl<std::decay_t<T>>; };
 
template <typename T>
using get_size_of_impl = typename size_of_impl_dispatcher<unwrap_type<T>>::type;
 
} // namespace detail
 
template <typename T>
constexpr size_type size_of(const T& v) {
    static_assert(HasDefinition<T>, "the type has not been defined with PostgreSQL type traits");
    return ozo::is_null(v) ? null_state_size : detail::get_size_of_impl<T>::apply(ozo::unwrap(v));
}
 
template <typename T, typename>
struct size_of_impl : detail::size_of_default_impl<T> {};
 
template <typename T>
constexpr size_type data_frame_size(const T& v) {
    return sizeof(ozo::size_type) + std::max(size_of(v), 0);
}
 
template <typename T>
constexpr size_type frame_size(const T& v) {
    return sizeof(ozo::oid_t) + data_frame_size(v);
}
 
} // namespace ozo