send.h

#pragma once
 
#include <ozo/core/concept.h>
#include <ozo/type_traits.h>
#include <ozo/io/size_of.h>
#include <ozo/io/ostream.h>
#include <ozo/io/type_traits.h>
#include <libpq-fe.h>
#include <type_traits>
 
namespace ozo {
 
template <typename In, typename = std::void_t<>>
struct send_impl{
    static_assert(HasDefinition<In>, "type In must be defined as PostgreSQL type");
 
    static_assert(
        Readable<In&>,
        "In object type can't be sent. Probably it is not an arithmetic or doens't have data and size methods"
        " or it is a struct with field which can't be sent."
    );
 
    template <typename OidMap>
    static ostream& apply(ostream& out, const OidMap&, const In& in) {
        return write(out, in);
    }
};
 
namespace detail {
 
template <typename T, typename = std::void_t<>>
struct send_impl_dispatcher { using type = send_impl<std::decay_t<T>>; };
 
template <typename T, typename Tag>
struct send_impl_dispatcher<strong_typedef_wrapper<T, Tag>> { using type = send_impl<std::decay_t<T>>; };
 
template <typename T>
using get_send_impl = typename send_impl_dispatcher<unwrap_type<T>>::type;
 
} // namespace detail
 
template <class OidMap, class In>
inline ostream& send(ostream& out, const OidMap& oid_map, const In& in) {
    return ozo::is_null(in) ? out : detail::get_send_impl<In>::apply(out, oid_map, ozo::unwrap(in));
}
 
template <class OidMap, class In>
inline ostream& send_data_frame(ostream& out, const OidMap& oid_map, const In& in) {
    write(out, size_of(in));
    return send(out, oid_map, in);
}
 
template <class OidMap, class In>
inline ostream& send_frame(ostream& out, const OidMap& oid_map, const In& in) {
    write(out, type_oid(oid_map, in));
    return send_data_frame(out, oid_map, in);
}
 
} // namespace ozo