connection.h

#pragma once
 
#include <ozo/error.h>
#include <ozo/type_traits.h>
#include <ozo/asio.h>
#include <ozo/core/concept.h>
#include <ozo/core/recursive.h>
#include <ozo/core/none.h>
#include <ozo/deadline.h>
#include <ozo/pg/handle.h>
 
#include <ozo/detail/bind.h>
#include <ozo/detail/functional.h>
 
#include <boost/asio/dispatch.hpp>
#include <boost/asio/posix/stream_descriptor.hpp>
 
namespace ozo {
 
using no_statistics = ozo::none_t;
 
template <typename T>
struct unwrap_connection_impl : unwrap_recursive_impl<T> {};
template <typename T>
inline constexpr decltype(auto) unwrap_connection(T&& conn) noexcept {
    return detail::apply<unwrap_connection_impl>(std::forward<T>(conn));
}
 
template <typename OidMap, typename Statistics>
class connection {
public:
    using native_handle_type = ozo::pg::conn::pointer; 
    using oid_map_type = OidMap; 
    using error_context_type = std::string; 
    using executor_type = io_context::executor_type; 
 
    connection(io_context& io, Statistics statistics);
 
    native_handle_type native_handle() const noexcept { return handle_.get(); }
 
    oid_map_type& oid_map() noexcept { return oid_map_;}
    const oid_map_type& oid_map() const noexcept { return oid_map_;}
 
    template <typename Key, typename Value>
    void update_statistics(const Key&, const Value&) noexcept {
        static_assert(std::is_void_v<Key>, "update_statistics is not supperted");
    }
    const Statistics& statistics() const noexcept { return statistics_;}
 
    const error_context_type& get_error_context() const noexcept { return error_context_; }
    void set_error_context(error_context_type v = error_context_type{}) { error_context_ = std::move(v); }
 
    executor_type get_executor() const noexcept { return io_->get_executor(); }
 
    error_code assign(ozo::pg::conn&& handle);
 
    ozo::pg::conn release();
 
    template <typename WaitHandler>
    void async_wait_write(WaitHandler&& handler);
 
    template <typename WaitHandler>
    void async_wait_read(WaitHandler&& handler);
 
    error_code close() noexcept;
 
    void cancel() noexcept;
 
    bool is_bad() const noexcept;
 
    operator bool () const noexcept { return !is_bad();}
 
    bool is_open() const noexcept { return native_handle() != nullptr;}
 
    ~connection();
private:
    using stream_type = asio::posix::stream_descriptor;
 
    ozo::pg::conn handle_;
    io_context* io_ = nullptr;
    stream_type socket_;
    oid_map_type oid_map_;
    Statistics statistics_;
    error_context_type error_context_;
};
 
template <typename, typename = std::void_t<>>
struct is_connection : std::false_type {};
 
template <typename ...Ts>
struct is_connection<connection<Ts...>> : std::true_type {};
 
template <typename T>
inline constexpr auto Connection = is_connection<std::decay_t<decltype(unwrap_connection(std::declval<T>()))>>::value;
 
 
template <typename Connection>
inline auto get_native_handle(const Connection& conn) noexcept;
 
template <typename Connection>
inline auto get_executor(const Connection& conn) noexcept;
 
template <typename T>
inline bool connection_bad(const T& conn) noexcept;
 
template <typename Connection>
inline bool connection_good(const Connection& conn) noexcept {
    return !connection_bad(conn);
}
 
template <typename Connection>
inline std::string_view error_message(const Connection& conn);
 
template <typename Connection>
inline const auto& get_error_context(const Connection& conn);
 
template <typename Connection>
inline std::string_view get_database(const Connection& conn);
 
template <typename Connection>
inline std::string_view get_host(const Connection& conn);
 
template <typename Connection>
inline std::string_view get_port(const Connection& conn);
 
template <typename Connection>
inline std::string_view get_user(const Connection& conn) ;
 
template <typename Connection>
inline std::string_view get_password(const Connection& conn);
 
namespace detail {
 
template <typename ConnectionProvider, typename = std::void_t<>>
struct get_connection_type_default {};
 
template <typename ConnectionProvider>
struct get_connection_type_default<ConnectionProvider,
    std::void_t<typename ConnectionProvider::connection_type>> {
    using type = typename ConnectionProvider::connection_type;
};
 
template <typename T>
struct get_connection_type_default<T, Require<ozo::Connection<T>>> {
    using type = T;
};
 
} // namespace detail
 
template <typename ConnectionProvider>
struct get_connection_type
#ifdef OZO_DOCUMENTATION
{
    using type = <implementation defined>; 
};
#else
 : detail::get_connection_type_default<ConnectionProvider>{};
#endif
 
template <typename T>
using connection_type = typename get_connection_type<std::decay_t<T>>::type;
 
template <typename T>
using handler_signature = void (error_code, connection_type<T>);
 
namespace detail {
 
struct call_async_get_connection {
    template <typename Provider, typename TimeConstraint, typename Handler>
    static constexpr auto apply(Provider&& p, TimeConstraint t, Handler&& h) ->
            decltype(p.async_get_connection(t, std::forward<Handler>(h))) {
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        return p.async_get_connection(t, std::forward<Handler>(h));
    }
};
 
struct forward_connection {
    template <typename Conn, typename TimeConstraint, typename Handler>
    static constexpr void apply(Conn&& c, TimeConstraint, Handler&& h) {
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        unwrap_connection(c).set_error_context();
        auto ex = unwrap_connection(c).get_executor();
        asio::dispatch(ex, detail::bind(std::forward<Handler>(h), error_code{}, std::forward<Conn>(c)));
    }
};
 
} // namespace detail
 
template <typename Provider, typename TimeConstraint>
struct async_get_connection_impl : std::conditional_t<Connection<Provider>,
    detail::forward_connection,
    detail::call_async_get_connection
> {};
 
namespace detail {
 
template <typename Source, typename TimeTraits, typename = std::void_t<>>
struct connection_source_supports_time_traits : std::false_type {};
 
template <typename Source, typename TimeTraits>
struct connection_source_supports_time_traits<Source, TimeTraits, std::void_t<decltype(
    std::declval<Source&>()(
        std::declval<io_context&>(),
        std::declval<TimeTraits>(),
        std::declval<handler_signature<Source>>()
    )
)>> : std::true_type {};
 
template <typename T>
using connection_source_defined = std::conjunction<
    typename connection_source_supports_time_traits<T, time_traits::time_point>::type,
    typename connection_source_supports_time_traits<T, time_traits::duration>::type,
    typename connection_source_supports_time_traits<T, none_t>::type
>;
} // namespace detail
 
template <typename T>
using is_connection_source = typename detail::connection_source_defined<T>::type;
 
template <typename T>
struct connection_source_traits {
    using type = connection_source_traits;
    using connection_type = typename get_connection_type<std::decay_t<T>>::type;
};
 
template <typename T>
inline constexpr auto ConnectionSource = is_connection_source<std::decay_t<T>>::value;
 
template <typename Provider, typename TimeConstraint, typename Handler>
constexpr auto async_get_connection(Provider&& p, TimeConstraint t, Handler&& h) ->
        decltype(async_get_connection_impl<std::decay_t<Provider>, TimeConstraint>::
            apply(std::forward<Provider>(p), t, std::forward<Handler>(h))) {
    static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
    return async_get_connection_impl<std::decay_t<Provider>, TimeConstraint>::
            apply(std::forward<Provider>(p), t, std::forward<Handler>(h));
}
 
namespace detail {
template <typename Provider, typename TimeConstraint, typename = std::void_t<>>
struct connection_provider_supports_time_constraint : std::false_type {};
 
template <typename Provider, typename TimeConstraint>
struct connection_provider_supports_time_constraint<Provider, TimeConstraint, std::void_t<decltype(
    async_get_connection(
        std::declval<Provider&>(),
        std::declval<TimeConstraint>(),
        std::declval<handler_signature<Provider>>()
    )
)>> : std::true_type {};
 
template <typename T>
using async_get_connection_defined = std::conjunction<
    typename connection_provider_supports_time_constraint<T, none_t>::type,
    typename connection_provider_supports_time_constraint<T, time_traits::duration>::type,
    typename connection_provider_supports_time_constraint<T, time_traits::time_point>::type
>;
 
} // namespace detail
 
template <typename T>
using is_connection_provider = typename detail::async_get_connection_defined<T>::type;
 
template <typename T>
struct connection_provider_traits {
    using type = connection_provider_traits;
    using connection_type = typename get_connection_type<std::decay_t<T>>::type;
};
 
template <typename T>
inline constexpr auto ConnectionProvider = is_connection_provider<std::decay_t<T>>::value;
 
#ifdef OZO_DOCUMENTATION
 
template <typename T, typename TimeConstraint, typename CompletionToken>
decltype(auto) get_connection(T&& provider, TimeConstraint time_constraint, CompletionToken&& token);
 
template <typename T, typename CompletionToken>
decltype(auto) get_connection(T&& provider, CompletionToken&& token);
#else
template <typename Initiator>
struct get_connection_op : base_async_operation <get_connection_op<Initiator>, Initiator> {
    using base = typename get_connection_op::base;
    using base::base;
 
    template <typename T, typename TimeConstraint, typename CompletionToken>
    decltype(auto) operator() (T&& provider, TimeConstraint t, CompletionToken&& token) const {
        static_assert(ConnectionProvider<T>, "T is not a ConnectionProvider concept");
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        return async_initiate<CompletionToken, handler_signature<T>>(
            get_operation_initiator(*this), token, std::forward<T>(provider), t
        );
    }
 
    template <typename T, typename CompletionToken>
    decltype(auto) operator() (T&& provider, CompletionToken&& token) const {
        return (*this)(std::forward<T>(provider), none, std::forward<CompletionToken>(token));
    }
 
    template <typename OtherInitiator>
    constexpr static auto rebind_initiator(const OtherInitiator& other) {
        return get_connection_op<OtherInitiator>{other};
    }
};
 
namespace detail {
struct initiate_async_get_connection {
    template <typename Provider, typename Handler, typename TimeConstraint>
    constexpr void operator()(Handler&& h, Provider&& p, TimeConstraint t) const {
        async_get_connection( std::forward<Provider>(p), t, std::forward<Handler>(h));
    }
};
} // namespace detail
 
inline constexpr get_connection_op<detail::initiate_async_get_connection> get_connection;
#endif
 
 
template <typename Connection>
inline error_code close_connection(Connection&& conn);
 
template <typename Connection>
inline auto defer_close_connection(Connection* conn) {
    static_assert(ozo::Connection<Connection>, "argument should model Connection");
 
    auto do_close = [] (auto conn_ptr) {
        if (!is_null_recursive(*conn_ptr)) {
            close_connection(*conn_ptr);
        }
    };
 
    return std::unique_ptr<Connection, decltype(do_close)>{conn, do_close};
}
 
} // namespace ozo
 
#include <ozo/impl/connection.h>