connection_info.h

#pragma once
 
#include <ozo/connector.h>
#include <ozo/connection.h>
#include <ozo/impl/async_connect.h>
#include <ozo/ext/std/shared_ptr.h>
 
#include <chrono>
 
namespace ozo {
 
template <
    typename OidMap = empty_oid_map,
    typename Statistics = no_statistics>
class connection_info {
    std::string conn_str;
    Statistics statistics;
 
public:
    using connection_type = std::shared_ptr<ozo::connection<OidMap, Statistics>>; 
 
    connection_info(std::string conn_str, const OidMap& = OidMap{}, Statistics statistics = Statistics{})
            : conn_str(std::move(conn_str)), statistics(std::move(statistics)) {
    }
 
    template <typename TimeConstraint, typename Handler>
    void operator ()(io_context& io, TimeConstraint t, Handler&& handler) const {
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        auto allocator = asio::get_associated_allocator(handler);
        impl::async_connect(conn_str, t, std::allocate_shared<ozo::connection<OidMap, Statistics>>(allocator, io, statistics),
            std::forward<Handler>(handler));
    }
 
    auto operator [](io_context& io) const & {
        return connection_provider(*this, io);
    }
 
    auto operator [](io_context& io) && {
        return connection_provider(std::move(*this), io);
    }
};
 
template<typename OidMap, typename Statistics>
connection_info(std::string, const OidMap&, Statistics statistics) -> connection_info<OidMap, Statistics>;
 
//[[DEPRECATED]] for backward compatibility only
template <typename ...Ts>
[[deprecated]] auto make_connector(const connection_info<Ts...>& source, io_context& io, time_traits::duration timeout) {
    return bind_get_connection_timeout(source[io], timeout);
}
 
//[[DEPRECATED]] for backward compatibility only
template <typename ...Ts>
[[deprecated]] auto make_connector(connection_info<Ts...>& source, io_context& io, time_traits::duration timeout) {
    return bind_get_connection_timeout(source[io], timeout);
}
 
//[[DEPRECATED]] for backward compatibility only
template <typename ...Ts>
[[deprecated]] auto make_connector(connection_info<Ts...>&& source, io_context& io, time_traits::duration timeout) {
    return bind_get_connection_timeout(source[io], timeout);
}
 
//[[DEPRECATED]] for backward compatibility only
template <typename ...Ts>
[[deprecated]] auto make_connector(const connection_info<Ts...>& source, io_context& io) { return source[io];}
 
//[[DEPRECATED]] for backward compatibility only
template <typename ...Ts>
[[deprecated]] auto make_connector(connection_info<Ts...>& source, io_context& io) { return source[io];}
 
//[[DEPRECATED]] for backward compatibility only
template <typename ...Ts>
[[deprecated]] auto make_connector(connection_info<Ts...>&& source, io_context& io) { return source[io];}
 
template <typename OidMap = empty_oid_map, typename Statistics = no_statistics>
inline auto make_connection_info(std::string conn_str, const OidMap& oid_map = OidMap{},
        Statistics statistics = Statistics{}) {
    return connection_info{std::move(conn_str), oid_map, statistics};
}
 
static_assert(ConnectionProvider<decltype(std::declval<connection_info<>>()[std::declval<io_context&>()])>, "is not a ConnectionProvider");
 
} // namespace ozo