session.hpp

Go to the documentation of this file.

#pragma once
 
#include "crypto.hpp"
#include "packet.hpp"
namespace mal_packet_weaver
{
    using PacketReceiverFn = std::function<void(std::unique_ptr<Packet> &&)>;
    class Session final : public non_copyable_non_movable, public std::enable_shared_from_this<Session>
    {
    public:
        explicit Session(boost::asio::io_context &io, boost::asio::ip::tcp::socket &&socket);
 
        virtual ~Session();
 
        template <IsPacket T>
        bool send_packet(const T &packet_arg) requires std::is_base_of_v<Packet, T>;
 
        std::unique_ptr<Packet> pop_packet_now();
 
        boost::asio::awaitable<std::unique_ptr<Packet>> pop_packet_async(boost::asio::io_context &io);
 
        [[nodiscard]] inline bool has_packets() { return !received_packets_.empty(); }
 
        [[nodiscard]] inline bool secured() const noexcept { return encryption_ != nullptr; }
 
        [[nodiscard]] constexpr bool is_closed() const noexcept { return !alive_; }
 
        [[nodiscard]] constexpr bool alive() const noexcept { return alive_; }
 
        void setup_encryption(std::shared_ptr<mal_packet_weaver::crypto::EncryptionInterface> encryption)
        {
            encryption_ = encryption;
        }
 
        void set_packet_receiver(PacketReceiverFn const receiver)
        {
            std::lock_guard guard{ packet_receiver_mutex_ };
            packet_receiver_ = receiver;
        }
 
        void Destroy() { alive_ = false; }
 
    private:
        std::unique_ptr<ByteArray> pop_packet_data() noexcept;
 
        boost::asio::awaitable<std::shared_ptr<Session>> get_shared_ptr(boost::asio::io_context &io);
 
        boost::asio::awaitable<void> send_all(boost::asio::io_context &io);
 
        boost::asio::awaitable<void> async_packet_forger(boost::asio::io_context &io);
        boost::asio::awaitable<void> async_packet_sender(boost::asio::io_context &io);
 
        boost::lockfree::queue<ByteArray *, boost::lockfree::fixed_sized<true>> received_packets_;
        boost::lockfree::queue<ByteArray *, boost::lockfree::fixed_sized<true>> packets_to_send_;
 
        bool alive_ = true;
        
        boost::asio::ip::tcp::tcp::socket socket_;
 
        std::shared_ptr<mal_packet_weaver::crypto::EncryptionInterface> encryption_ = nullptr;
 
        std::mutex packet_receiver_mutex_;
 
        PacketReceiverFn packet_receiver_;
    };
}  // namespace mal_packet_weaver
#include "session.inl"