tcp.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <memory>
#include <string_view>
#include <sys/socket.h>
#include "../include/io_context.hpp"
#include <event2/bufferevent.h>
 
namespace tcp {
class Connection : public std::enable_shared_from_this<Connection> {
    using length_header = int32_t;
    static constexpr size_t header_size{ sizeof(length_header )};
public:
    using connection_ptr = std::shared_ptr<Connection>;
    using event_ptr = std::unique_ptr<bufferevent, decltype(&bufferevent_free)>;
    Connection(const Connection&) = delete;
    Connection& operator=(const Connection&) = delete;
 
    Connection(Connection&& other) noexcept;
 
    Connection &operator=(Connection&& other) noexcept;
 
    static connection_ptr create(int32_t socket_fd, async::IOContext::io_context_ptr io_context);
 
    void set_nonblocking();
 
    bool is_nonblocking();
 
    void send_async(std::string_view msg, std::function<void()> callback);
 
    void recv_async(std::vector<std::byte> buf, std::function<void()> callback);
 
    void send_sync(std::string_view msg);
 
    void recv_sync(std::string &buf);
private:
    Connection(int32_t socket_fd, async::IOContext::io_context_ptr io_context = nullptr) :
        socket_fd_{ socket_fd },
        io_context_{ io_context },
        event_(nullptr, bufferevent_free) {}
 
    int32_t socket_fd_; 
    std::shared_ptr<async::IOContext> io_context_; 
    event_ptr event_; 
};
 
class Acceptor {
public:
    Acceptor(std::string port, int32_t domain);
 
    ~Acceptor();
 
    Acceptor(const Acceptor&) = delete;
    Acceptor& operator=(const Acceptor&) = delete;
 
    Acceptor(Acceptor&& other) noexcept;
 
    Acceptor& operator=(Acceptor&& other) noexcept;
 
    void bind() const;
 
    void listen() const;
 
    Connection::connection_ptr accept() const;
private:
    int32_t listening_socket_fd_; 
    std::string port_; 
};
}