Connection.hpp

#pragma once
 
#include "util/Taggable.hpp"
#include "web/ng/Error.hpp"
#include "web/ng/Request.hpp"
#include "web/ng/Response.hpp"
 
#include <boost/asio/spawn.hpp>
#include <boost/beast/core/flat_buffer.hpp>
 
#include <chrono>
#include <concepts>
#include <cstddef>
#include <expected>
#include <memory>
#include <optional>
#include <string>
#include <utility>
 
namespace web::ng {

class ConnectionMetadata : public util::Taggable {
protected:
    std::string ip_;  // client ip
    std::optional<bool> isAdmin_;
 
public:
    ConnectionMetadata(std::string ip, util::TagDecoratorFactory const& tagDecoratorFactory);

    virtual bool
    wasUpgraded() const = 0;

    std::string const&
    ip() const;

    void
    setIp(std::string newIp)
    {
        ip_ = std::move(newIp);
    }

    bool
    isAdmin() const;

    template <std::invocable T>
    void
    setIsAdmin(T&& setter)
    {
        if (not isAdmin_.has_value())
            isAdmin_ = setter();
    }
};

class Connection : public ConnectionMetadata {
protected:
    boost::beast::flat_buffer buffer_;
 
public:
    static constexpr std::chrono::steady_clock::duration kDEFAULT_TIMEOUT =
        std::chrono::seconds{11};

    Connection(
        std::string ip,
        boost::beast::flat_buffer buffer,
        util::TagDecoratorFactory const& tagDecoratorFactory
    );

    virtual void
    setTimeout(std::chrono::steady_clock::duration newTimeout) = 0;

    virtual std::expected<void, Error>
    send(Response response, boost::asio::yield_context yield) = 0;

    virtual std::expected<Request, Error>
    receive(boost::asio::yield_context yield) = 0;

    virtual void
    close(boost::asio::yield_context yield) = 0;
};

using ConnectionPtr = std::unique_ptr<Connection>;
 
}  // namespace web::ng