dispatcher-session.hpp

Go to the documentation of this file.

#pragma once
#include "packet-dispatcher.hpp"
#include "session.hpp"
namespace mal_packet_weaver
{
    class DispatcherSession final : public non_copyable_non_movable
    {
    public:
        DispatcherSession(boost::asio::io_context &io_context, boost::asio::ip::tcp::socket &&socket)
            : io_context_{ io_context },
              session_{ std::make_shared<Session>(io_context, std::move(socket)) },
              dispatcher_{ std::make_shared<PacketDispatcher>(io_context) }
        {
            session_->set_packet_receiver([&dispatcher_ = *dispatcher_](std::unique_ptr<Packet> &&packet)
                                              __mal_toolkit_lambda_force_inline  { dispatcher_.enqueue_packet(std::move(packet)); });
        }
 
        ~DispatcherSession()
        {
            if (session_ != nullptr)
            {
                session_->Destroy();
            }
            if (dispatcher_ != nullptr)
            {
                dispatcher_->Destroy();
            }
        }
 
        template <IsPacket T>
        inline bool send_packet(const T &packet_arg) requires std::is_base_of_v<Packet, T>
        {
            return session_->send_packet(packet_arg);
        }
 
        inline std::unique_ptr<Packet> pop_packet_now() { return session_->pop_packet_now(); }
 
        inline boost::asio::awaitable<std::unique_ptr<Packet>> pop_packet_async()
        {
            auto value = co_await session_->pop_packet_async(io_context_);
            co_return std::move(value);
        }
 
        [[nodiscard]] inline bool has_packets() { return session_->has_packets(); }
 
        [[nodiscard]] inline bool secured() const noexcept { return session_->secured(); }
 
        [[nodiscard]] constexpr bool is_closed() const noexcept { return session_->is_closed(); }
 
        [[nodiscard]] constexpr bool alive() const noexcept { return session_->alive(); }
 
        inline void setup_encryption(std::shared_ptr<mal_packet_weaver::crypto::EncryptionInterface> encryption)
        {
            session_->setup_encryption(encryption);
        }
 
        inline void set_packet_receiver(PacketReceiverFn const receiver) { session_->set_packet_receiver(receiver); }
 
        inline void enqueue_packet(PacketDispatcher::BasePacketPtr &&packet)
        {
            dispatcher_->enqueue_packet(std::move(packet));
        }
 
        template <IsPacket DerivedPacket>
        boost::asio::awaitable<std::unique_ptr<DerivedPacket>> await_packet(float timeout = -1.0f)
        {
            return dispatcher_->await_packet<DerivedPacket>(timeout);
        }
 
        template <IsPacket DerivedPacket>
        boost::asio::awaitable<std::unique_ptr<DerivedPacket>> await_packet(PacketFilterFunc<DerivedPacket> filter,
                                                                            float timeout = -1.0f)
        {
            return dispatcher_->await_packet<DerivedPacket>(filter, timeout);
        }
 
        template <IsPacket DerivedPacket>
        inline void register_default_handler(PacketHandlerFunc<DerivedPacket> handler,
                                             PacketFilterFunc<DerivedPacket> filter = {}, float delay = 0.0f)
        {
            return dispatcher_->register_default_handler(handler, filter, delay);
        }
        template <typename Arg1, IsPacket CustomPacket>
        inline void register_default_handler(PacketHandlerFunc<CustomPacket, Arg1> &&handler,
                                             PacketFilterFunc<CustomPacket, Arg1> &&filter = {}, float delay = 0.0f)
        {
            if constexpr (std::is_same_v<Arg1, std::shared_ptr<Session>>)
            {
                return register_default_handler<CustomPacket>(
                    [session_ = std::weak_ptr<Session>(session_), moved_handler = std::move(handler)](
                        std::unique_ptr<CustomPacket> &&packet) { moved_handler(session_.lock(), std::move(packet)); },
                    (bool(filter) ? ([session_ = std::weak_ptr<Session>(session_), moved_filter = std::move(filter)](
                                         const CustomPacket &packet) { return moved_filter(session_.lock(), packet); })
                                  : PacketFilterFunc<CustomPacket>{}),
                    delay);
            }
            else if constexpr (std::is_same_v<Arg1, Session &>)
            {
                return register_default_handler<CustomPacket>(
                    [session_ = std::weak_ptr<Session>(session_), moved_handler = std::move(handler)](
                        std::unique_ptr<CustomPacket> &&packet) { moved_handler(*session_.lock(), std::move(packet)); },
                    (bool(filter) ? ([session_ = std::weak_ptr<Session>(session_), moved_filter = std::move(filter)](
                                         const CustomPacket &packet) { return moved_filter(*session_.lock(), packet); })
                                  : PacketFilterFunc<CustomPacket>{}),
                    delay);
            }
            else if constexpr (std::is_same_v<Arg1, boost::asio::io_context &>)
            {
                return register_default_handler<CustomPacket>(
                    [io_context_ = std::ref(io_context_), moved_handler = std::move(handler)](
                        std::unique_ptr<CustomPacket> &&packet) { moved_handler(io_context_, std::move(packet)); },
                    (bool(filter) ? ([io_context_ = std::ref(io_context_), moved_filter = std::move(filter)](
                                         const CustomPacket &packet) { return moved_filter(io_context_, packet); })
                                  : PacketFilterFunc<CustomPacket>{}),
                    delay);
            }
            else if constexpr (std::is_same_v<Arg1, std::shared_ptr<PacketDispatcher>>)
            {
                return register_default_handler<CustomPacket>(
                    [dispatcher_ = std::weak_ptr<PacketDispatcher>(dispatcher_),
                     moved_handler = std::move(handler)](std::unique_ptr<CustomPacket> &&packet)
                    { moved_handler(dispatcher_.lock(), std::move(packet)); },
                    (bool(filter) ? ([dispatcher_ = std::weak_ptr<PacketDispatcher>(dispatcher_),
                                      moved_filter = std::move(filter)](const CustomPacket &packet)
                                     { return moved_filter(dispatcher_.lock(), packet); })
                                  : PacketFilterFunc<CustomPacket>{}),
                    delay);
            }
            else if constexpr (std::is_same_v<Arg1, PacketDispatcher &>)
            {
                return register_default_handler<CustomPacket>(
                    [dispatcher_ = std::weak_ptr<PacketDispatcher>(dispatcher_),
                     moved_handler = std::move(handler)](std::unique_ptr<CustomPacket> &&packet)
                    { moved_handler(*dispatcher_.lock(), std::move(packet)); },
                    (bool(filter) ? ([dispatcher_ = std::weak_ptr<PacketDispatcher>(dispatcher_),
                                      moved_filter = std::move(filter)](const CustomPacket &packet)
                                     { return moved_filter(*dispatcher_.lock(), packet); })
                                  : PacketFilterFunc<CustomPacket>{}),
                    delay);
            }
            else
            {
                []<bool flag = false>()
                {
                    static_assert(flag,
                                  "Unknown type passed! Supported types for handler are: Session&, "
                                  "std::shared_ptr<Session>, io_context &, std::shared_ptr<PacketDispatcher> and "
                                  "PacketDispatcher&. The CustomPacket type should be last.");
                }
                ();
            }
        }
 
        template <typename Arg1, typename Arg2, typename... Args, IsPacket CustomPacket>
        inline void register_default_handler(PacketHandlerFunc<CustomPacket, Arg1, Arg2, Args...> &&handler,
                                             PacketFilterFunc<CustomPacket, Arg1, Arg2, Args...> &&filter = {},
                                             float delay = 0.0f)
        {
            if constexpr (std::is_same_v<Arg1, std::shared_ptr<Session>>)
            {
                return register_default_handler<Arg2, Args..., CustomPacket>(
                    [session_ = std::weak_ptr<Session>(session_), moved_handler = std::move(handler)](
                        Arg2 &&arg2, Args &&...args, std::unique_ptr<CustomPacket> &&packet) {
                        moved_handler(session_.lock(), std::forward<Arg2>(arg2), std::forward<Args>(args)...,
                                      std::move(packet));
                    },
                    (bool(filter) ? (
                                        [session_ = std::weak_ptr<Session>(session_), moved_filter = std::move(filter)](
                                            Arg2 &&arg2, Args &&...args, const CustomPacket &packet) {
                                            return moved_filter(session_.lock(), std::forward<Arg2>(arg2),
                                                                std::forward<Args>(args)..., packet);
                                        })
                                  : PacketFilterFunc<CustomPacket, Arg2, Args...>{}),
                    delay);
            }
            else if constexpr (std::is_same_v<Arg1, Session &>)
            {
                return register_default_handler<Arg2, Args..., CustomPacket>(
                    [session_ = std::weak_ptr<Session>(session_), moved_handler = std::move(handler)](
                        Arg2 &&arg2, Args &&...args, std::unique_ptr<CustomPacket> &&packet) {
                        moved_handler(*session_.lock(), std::forward<Arg2>(arg2), std::forward<Args>(args)...,
                                      std::move(packet));
                    },
                    (bool(filter) ? (
                                        [session_ = std::weak_ptr<Session>(session_), moved_filter = std::move(filter)](
                                            Arg2 &&arg2, Args &&...args, const CustomPacket &packet) {
                                            return moved_filter(*session_.lock(), std::forward<Arg2>(arg2),
                                                                std::forward<Args>(args)..., packet);
                                        })
                                  : PacketFilterFunc<CustomPacket, Arg2, Args...>{}),
                    delay);
            }
            else if constexpr (std::is_same_v<Arg1, boost::asio::io_context &>)
            {
                return register_default_handler<Arg2, Args..., CustomPacket>(
                    [io_context_ = std::ref(io_context_), moved_handler = std::move(handler)](
                        Arg2 &&arg2, Args &&...args, std::unique_ptr<CustomPacket> &&packet) {
                        moved_handler(io_context_, std::forward<Arg2>(arg2), std::forward<Args>(args)...,
                                      std::move(packet));
                    },
                    (bool(filter) ? (
                                        [io_context_ = std::ref(io_context_), moved_filter = std::move(filter)](
                                            Arg2 &&arg2, Args &&...args, const CustomPacket &packet) {
                                            return moved_filter(io_context_, std::forward<Arg2>(arg2),
                                                                std::forward<Args>(args)..., packet);
                                        })
                                  : PacketFilterFunc<CustomPacket, Arg2, Args...>{}),
                    delay);
            }
            else if constexpr (std::is_same_v<Arg1, std::shared_ptr<PacketDispatcher>>)
            {
                return register_default_handler<Arg2, Args..., CustomPacket>(
                    [dispatcher_ = std::weak_ptr<PacketDispatcher>(dispatcher_), moved_handler = std::move(handler)](
                        Arg2 &&arg2, Args &&...args, std::unique_ptr<CustomPacket> &&packet) {
                        moved_handler(dispatcher_.lock(), std::forward<Arg2>(arg2), std::forward<Args>(args)...,
                                      std::move(packet));
                    },
                    (bool(filter) ? (
                                        [dispatcher_ = std::weak_ptr<PacketDispatcher>(dispatcher_),
                                         moved_filter = std::move(filter)](Arg2 &&arg2, Args &&...args,
                                                                           const CustomPacket &packet) {
                                            return moved_filter(dispatcher_.lock(), std::forward<Arg2>(arg2),
                                                                std::forward<Args>(args)..., packet);
                                        })
                                  : PacketFilterFunc<CustomPacket, Arg2, Args...>{}),
                    delay);
            }
            else if constexpr (std::is_same_v<Arg1, PacketDispatcher &>)
            {
                return register_default_handler<Arg2, Args..., CustomPacket>(
                    [dispatcher_ = std::weak_ptr<PacketDispatcher>(dispatcher_), moved_handler = std::move(handler)](
                        Arg2 &&arg2, Args &&...args, std::unique_ptr<CustomPacket> &&packet) {
                        moved_handler(*dispatcher_.lock(), std::forward<Arg2>(arg2), std::forward<Args>(args)...,
                                      std::move(packet));
                    },
                    (bool(filter) ? (
                                        [dispatcher_ = std::weak_ptr<PacketDispatcher>(dispatcher_),
                                         moved_filter = std::move(filter)](Arg2 &&arg2, Args &&...args,
                                                                           const CustomPacket &packet) {
                                            return moved_filter(*dispatcher_.lock(), std::forward<Arg2>(arg2),
                                                                std::forward<Args>(args)..., packet);
                                        })
                                  : PacketFilterFunc<CustomPacket, Arg2, Args...>{}),
                    delay);
            }
            else
            {
                []<bool flag = false>()
                {
                    static_assert(flag,
                                  "Unknown type passed! Supported types for handler are: Session&, "
                                  "std::shared_ptr<Session>, io_context &, std::shared_ptr<PacketDispatcher> and "
                                  "PacketDispatcher&. The CustomPacket type should be last.");
                }
                ();
            }
        }
 
        template <IsPacket CustomPacket, typename... FnArgs>
        inline void register_default_handler(std::function<void(FnArgs...)> &&handler,
                                             std::function<bool(FnArgs...)> &&filter = {}, float delay = 0.0f)
        {
            return register_default_handler<FnArgs..., CustomPacket>(handler, filter, delay);
        }
        inline void enqueue_promise(UniquePacketID packet_id, PacketDispatcher::shared_packet_promise promise)
        {
            return dispatcher_->enqueue_promise(packet_id, promise);
        }
 
        inline void enqueue_filter_promise(UniquePacketID packet_id, PacketDispatcher::promise_filter filtered_promise)
        {
            return dispatcher_->enqueue_filter_promise(packet_id, filtered_promise);
        }
 
        [[nodiscard]] inline Session &session() { return *session_; }
 
        [[nodiscard]] inline PacketDispatcher &dispatcher() { return *dispatcher_; }
 
        void Destroy()
        {
            session_->Destroy();
            dispatcher_->Destroy();
        }
 
    private:
        boost::asio::io_context &io_context_;           
        std::shared_ptr<Session> session_;              
        std::shared_ptr<PacketDispatcher> dispatcher_;  
    };
}  // namespace mal_packet_weaver