strategy.h

#pragma once
 
#include <ozo/type_traits.h>
#include <ozo/asio.h>
#include <ozo/deadline.h>
#include <ozo/connection.h>
 
#include <tuple>
 
 
#ifdef OZO_DOCUMENTATION
namespace ozo {
template <typename T>
constexpr auto FailoverStrategy = std::false_type;
 
template <typename T>
constexpr auto FailoverTry = std::false_type;
}
#endif
 
namespace ozo::failover {
 
namespace hana = boost::hana;
 
template <
    typename ConnectionProvider,
    typename TimeConstraint,
    typename ...Args>
struct basic_context {
    static_assert(ozo::TimeConstraint<TimeConstraint>, "TimeConstraint should models ozo::TimeConstraint");
    static_assert(ozo::ConnectionProvider<ConnectionProvider>, "ConnectionProvider should models ozo::ConnectionProvider");
 
    std::decay_t<ConnectionProvider> provider; 
    TimeConstraint time_constraint; 
    hana::tuple<std::decay_t<Args>...> args; 
 
    basic_context(ConnectionProvider p, TimeConstraint t, Args ...args)
    : provider(std::forward<ConnectionProvider>(p)),
      time_constraint(t),
      args(std::forward<Args>(args)...) {}
};
 
template <typename FailoverStrategy, typename Operation>
struct get_first_try_impl {
    template <typename Allocator, typename ...Args>
    static auto apply(const Operation& op, const FailoverStrategy& s, const Allocator& alloc, Args&& ...args) {
        return s.get_first_try(op, alloc, std::forward<Args>(args)...);
    }
};
 
template <typename FailoverStrategy, typename Operation, typename Allocator, typename ...Args>
inline auto get_first_try(const Operation& op, const FailoverStrategy& strategy, const Allocator& alloc, Args&& ...args) {
    return get_first_try_impl<FailoverStrategy, Operation>::apply(op, strategy, alloc, std::forward<Args>(args)...);
}
 
template <typename Try>
struct get_try_context_impl {
    static decltype(auto) apply(const Try& a_try) {
        return a_try.get_context();
    }
};
 
template <typename FailoverTry>
inline auto get_try_context(const FailoverTry& a_try) {
    auto res = detail::apply<get_try_context_impl>(ozo::unwrap(a_try));
    static_assert(HanaSequence<decltype(res)>,
        "get_try_context_impl::apply() should provide HanaSequence");
    return res;
}
 
template <typename Try>
struct get_next_try_impl {
    template <typename Conn>
    static auto apply(Try& a_try, error_code ec, Conn&& conn) {
        return a_try.get_next_try(ec, conn);
    }
};
 
template <typename Try, typename Connection>
inline auto get_next_try(Try& a_try, const error_code& ec, Connection& conn) {
    return detail::apply<get_next_try_impl>(ozo::unwrap(a_try), ec, conn);
}
 
template <typename Try>
struct initiate_next_try_impl {
    template <typename Connection, typename Initiator>
    static auto apply(Try& a_try, const error_code& ec, Connection& conn, Initiator init) {
        if (auto next = get_next_try(a_try, ec, conn); !ozo::is_null(next)) {
            init(std::move(next));
        }
    }
};
 
template <typename Try, typename Connection, typename Initiator>
inline auto initiate_next_try(Try& a_try, const error_code& ec, Connection& conn, Initiator&& init) {
    return detail::apply<initiate_next_try_impl>(ozo::unwrap(a_try), ec, conn, std::forward<Initiator>(init));
}
 
namespace detail {
 
template <template<typename...> typename Template, typename Allocator, typename ...Ts>
static auto allocate_shared(const Allocator& alloc, Ts&& ...vs) {
    using type = decltype(Template{std::forward<Ts>(vs)...});
    return std::allocate_shared<type>(alloc, std::forward<Ts>(vs)...);
}
 
template <typename Try, typename Operation, typename Handler>
inline void initiate_operation(const Operation&, Try&&, Handler&&);
 
template <typename Operation, typename Try, typename Handler>
struct continuation {
    Operation op_;
    Try try_;
    Handler handler_;
 
    continuation(const Operation& op, Try a_try, Handler handler)
    : op_(op), try_(std::move(a_try)), handler_(std::move(handler)) {}
 
    template <typename Connection>
    void operator() (error_code ec, Connection&& conn) {
        static_assert(ozo::Connection<Connection>, "conn should model Connection concept");
        if (ec) {
            bool initiated = false;
 
            initiate_next_try(try_, ec, conn, [&] (auto next_try) {
                initiate_operation(op_, std::move(next_try), std::move(handler_));
                initiated = true;
            });
 
            if (initiated) {
                return;
            }
        }
        handler_(std::move(ec), std::forward<Connection>(conn));
    }
 
    using executor_type = decltype(asio::get_associated_executor(handler_));
 
    executor_type get_executor() const {
        return asio::get_associated_executor(handler_);
    }
 
    using allocator_type = decltype(asio::get_associated_allocator(handler_));
 
    allocator_type get_allocator() const {
        return asio::get_associated_allocator(handler_);
    }
};
 
template <typename Try, typename Operation, typename Handler>
inline void initiate_operation(const Operation& op, Try&& a_try, Handler&& handler) {
    hana::unpack(get_try_context(a_try), [&](auto&& ...args) {
        ozo::get_operation_initiator(op)(
            continuation{op, std::forward<Try>(a_try), std::forward<Handler>(handler)},
            std::forward<decltype(args)>(args)...
        );
    });
}
 
template <typename FailoverStrategy, typename Operation>
struct operation_initiator {
    FailoverStrategy strategy_;
    Operation op_;
 
    constexpr operation_initiator(FailoverStrategy strategy, const Operation& op)
    : strategy_(std::move(strategy)), op_(op) {}
 
    template <typename Handler, typename ...Args>
    void operator() (Handler&& handler, Args&& ...args) const {
        auto first_try = get_first_try(op_, strategy_, asio::get_associated_allocator(handler), std::forward<Args>(args)...);
        initiate_operation(op_, std::move(first_try), std::forward<Handler>(handler));
    }
};
 
} // namespace detail
 
struct construct_initiator_impl {
    template <typename FailoverStrategy, typename Op>
    constexpr static auto apply(FailoverStrategy&& strategy, const Op& op) {
        return detail::operation_initiator(std::forward<FailoverStrategy>(strategy), op);
    }
};
} // namespace ozo::failover