session.hpp

#pragma once
 
#include "telnetpp/core.hpp"
#include "telnetpp/element.hpp"
 
#include <functional>
#include <memory>
 
namespace telnetpp {
 
class client_option;
class server_option;
 
//* =========================================================================
//* =========================================================================
class TELNETPP_EXPORT session final  // NOLINT
{
public:
    //* =====================================================================
    //* =====================================================================
    template <typename Channel>
    explicit session(Channel &channel) : session{}
    {
        channel_ = std::unique_ptr<channel_concept>(
            std::make_unique<channel_model<Channel>>(channel));
    }
 
    //* =====================================================================
    //* =====================================================================
    ~session();
 
    //* =====================================================================
    //* =====================================================================
    [[nodiscard]] bool is_alive() const;
 
    //* =====================================================================
    //* =====================================================================
    void close();
 
    //* =====================================================================
    //* =====================================================================
    void async_read(std::function<void(telnetpp::bytes)> const &callback);
 
    //* =====================================================================
    //* =====================================================================
    void write(telnetpp::element const &elem);
 
    //* =====================================================================
    //* =====================================================================
    void install(
        telnetpp::command_type cmd,
        std::function<void(telnetpp::command)> const &handler);
 
    //* =====================================================================
    //* =====================================================================
    void install(telnetpp::client_option &option);
 
    //* =====================================================================
    //* =====================================================================
    void install(telnetpp::server_option &option);
 
private:
    //* =====================================================================
    //* =====================================================================
    session();
 
    //* =====================================================================
    //* =====================================================================
    struct channel_concept
    {
        //* =================================================================
        //* =================================================================
        virtual ~channel_concept() = default;
 
        //* =================================================================
        //* =================================================================
        virtual void async_read(std::function<void(bytes)> const &) = 0;
 
        //* =================================================================
        //* =================================================================
        virtual void write(bytes data) = 0;
 
        //* =================================================================
        //* =================================================================
        [[nodiscard]] virtual bool is_alive() const = 0;
 
        //* =================================================================
        //* =================================================================
        virtual void close() = 0;
    };
 
    template <typename Channel>
    struct channel_model final : channel_concept
    {
        //* =================================================================
        //* =================================================================
        explicit channel_model(Channel &channel) : channel_{channel}
        {
        }
 
        //* =================================================================
        //* =================================================================
        void async_read(std::function<void(bytes)> const &callback) override
        {
            channel_.async_read(callback);
        }
 
        //* =================================================================
        //* =================================================================
        void write(bytes data) override
        {
            channel_.write(data);
        }
 
        //* =================================================================
        //* =================================================================
        [[nodiscard]] bool is_alive() const override
        {
            return channel_.is_alive();
        }
 
        //* =================================================================
        //* =================================================================
        void close() override
        {
            channel_.close();
        }
 
    private:
        Channel &channel_;
    };
 
    struct impl;
    std::unique_ptr<channel_concept> channel_;
    std::unique_ptr<impl> pimpl_;
};
 
}  // namespace telnetpp