io_handler.h

Go to the documentation of this file.

 
#ifndef QB_IO_ASYNC_IO_HANDLER_H
#define QB_IO_ASYNC_IO_HANDLER_H
 
#include <qb/system/container/unordered_map.h>
#include <qb/uuid.h>
#include <qb/io/async/event/extracted.h>
 
namespace qb::io::async {

template <typename _Derived, typename _Session>
class io_handler {
    friend typename _Session::base_io_t;

    void
    disconnected(uuid ident) {
        _sessions.erase(ident);
    }
 
public:
    using session_map_t = qb::unordered_map<uuid, std::shared_ptr<_Session>>;
 
private:
    session_map_t _sessions; 
 
public:
    using IOSession = _Session;

    io_handler() = default;

    ~io_handler() = default;

    session_map_t &
    sessions() {
        return _sessions;
    }

    std::shared_ptr<_Session>
    session(uuid id) {
        auto it = _sessions.find(id);
        return (it != std::end(_sessions)) ? it->second : nullptr;
    }

    template <typename... Args>
    _Session &
    registerSession(typename _Session::transport_io_type &&new_io, Args &&...args) {
        auto session = std::make_shared<_Session>(static_cast<_Derived &>(*this),
                                                  std::forward<Args>(args)...);
        sessions().emplace(session->id(), session);
        session->transport() = std::move(new_io);
        session->start();
        if constexpr (has_method_on<_Derived, void, _Session &>::value)
            static_cast<_Derived &>(*this).on(*session);
        return *session;
    }

    void
    unregisterSession(uuid const &ident) {
        auto it = _sessions.find(ident);
        if (it != _sessions.cend())
            it->second->disconnect();
    }

    [[nodiscard]] std::pair<typename _Session::transport_io_type, bool>
    extractSession(uuid const &ident) {
        auto it = _sessions.find(ident);
        if (it != _sessions.cend()) {
            if constexpr (has_method_on<_Session, void, qb::io::async::event::extracted>::value)
                (*it->second).on(qb::io::async::event::extracted{});
            auto t_io = std::move(it->second->transport());
            _sessions.erase(it);
            return {std::move(t_io), true};
        }
        return {typename _Session::transport_io_type{}, false};
    }

    template <typename... _Args>
    _Derived &
    stream(_Args &&...args) {
        for (auto &[key, session] : sessions())
            (*session << ... << std::forward<_Args>(args));
        return static_cast<_Derived &>(*this);
    }

    template <typename _Func, typename... _Args>
    _Derived &
    stream_if(_Func const &func, _Args &&...args) {
        for (auto &[key, session] : sessions())
            if (func(*session))
                (*session << ... << std::forward<_Args>(args));
        return static_cast<_Derived &>(*this);
    }
};
 
} // namespace qb::io::async
 
#endif // QB_IO_ASYNC_IO_HANDLER_H