subscribe.hpp

#pragma once
 
#include <rpp/observables/details/member_overload.hpp>
#include <rpp/subscribers/constraints.hpp>
#include <rpp/subscribers/specific_subscriber.hpp>
#include <rpp/subscriptions/composite_subscription.hpp>
 
 
namespace rpp::details
{
struct subscribe_tag;
 
 
template<constraint::decayed_type Type, typename SpecificObservable>
struct member_overload<Type, SpecificObservable, subscribe_tag>
{
    template<constraint::subscriber_of_type<Type> TSub>
    auto subscribe(TSub&& subscriber) const
    {
        return subscribe_impl(std::forward<TSub>(subscriber));
    }
 
    template<constraint::observer_of_type<Type> TObserver>
    auto subscribe(TObserver&& observer) const
    {
        return subscribe_impl<std::decay_t<TObserver>>(std::forward<TObserver>(observer));
    }
 
    template<constraint::observer_of_type<Type> TObserver>
    auto subscribe(composite_subscription sub, TObserver&& observer) const
    {
        return subscribe_impl(specific_subscriber<Type, std::decay_t<TObserver>>{std::move(sub), std::forward<TObserver>(observer)});
    }
 
    template<constraint::on_next_fn<Type> TOnNext      = utils::empty_function_t<Type>,
             constraint::on_error_fn      TOnError     = utils::rethrow_error_t,
             constraint::on_completed_fn  TOnCompleted = utils::empty_function_t<>>
    auto subscribe(TOnNext&& on_next = {}, TOnError&& on_error = {}, TOnCompleted&& on_completed = {}) const
    {
        return subscribe_impl(make_specific_subscriber<Type>(std::forward<TOnNext>(on_next), std::forward<TOnError>(on_error), std::forward<TOnCompleted>(on_completed)));
    }
 
    template<constraint::on_next_fn<Type> TOnNext, constraint::on_completed_fn  TOnCompleted>
    auto subscribe(TOnNext&& on_next, TOnCompleted&& on_completed) const
    {
        return subscribe_impl(make_specific_subscriber<Type>(std::forward<TOnNext>(on_next), std::forward<TOnCompleted>(on_completed)));
    }
 
    template<constraint::on_next_fn<Type> TOnNext      = utils::empty_function_t<Type>,
             constraint::on_error_fn      TOnError     = utils::rethrow_error_t,
             constraint::on_completed_fn  TOnCompleted = utils::empty_function_t<>>
    auto subscribe(composite_subscription sub, TOnNext&& on_next = {}, TOnError&& on_error = {}, TOnCompleted&& on_completed = {}) const
    {
        return subscribe_impl(make_specific_subscriber<Type>(std::move(sub), std::forward<TOnNext>(on_next), std::forward<TOnError>(on_error), std::forward<TOnCompleted>(on_completed)));
    }
 
    template<constraint::on_next_fn<Type> TOnNext,
             constraint::on_completed_fn  TOnCompleted>
    auto subscribe(composite_subscription sub, TOnNext&& on_next, TOnCompleted&& on_completed) const
    {
        return subscribe_impl(make_specific_subscriber<Type>(std::move(sub), std::forward<TOnNext>(on_next), std::forward<TOnCompleted>(on_completed)));
    }
 
private:
    template<constraint::observer_of_type<Type> Obs>
    auto subscribe_impl(const specific_subscriber<Type, Obs>& subscriber) const
    {
        return static_cast<const SpecificObservable*>(this)->subscribe_impl(subscriber);
    }
};
} // namespace rpp::details