tcp_acceptor.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_TCP_TCP_ACCEPTOR_HPP__
#define NEFORCE_NETWORK_TCP_TCP_ACCEPTOR_HPP__

 
#include "NeForce/network/tcp/tcp_socket.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API tcp_acceptor : public ip_socket {
public:
    using socket_base::open;
 
private:
    using ip_socket::connect;
    using socket_base::shutdown_both;
    using socket_base::shutdown_receive;
    using socket_base::shutdown_send;
 
public:
    tcp_acceptor() = default;

    void open(const ip_address& endpoint, int backlog = SOMAXCONN);

    NEFORCE_NODISCARD tcp_socket accept();

    NEFORCE_NODISCARD optional<tcp_socket> accept_nonblock();

    void async_accept(io_context& ctx, function<void(error_code, tcp_socket)> handler);

    void async_accept(io_context& ctx, cancellation_slot& slot, function<void(error_code, tcp_socket)> handler);

    template <typename Token, enable_if_t<!is_same_v<decay_t<Token>, function<void(error_code, tcp_socket)>>, int> = 0>
    void async_accept(io_context& ctx, Token&& token) {
        async_accept(ctx, function<void(error_code, tcp_socket)>(forward<Token>(token)));
    }

    decltype(auto) async_accept(io_context& ctx, use_future_t /*unused*/) {
        async_result<use_future_t, void(error_code, tcp_socket)> result(use_future);
        async_accept(ctx, function<void(error_code, tcp_socket)>(result.get_handler()));
        return result.get();
    }

    void async_accept(io_context& ctx, detached_t /*unused*/) {
        async_accept(ctx, function<void(error_code, tcp_socket)>([](error_code, tcp_socket) {}));
    }
 
#ifdef NEFORCE_STANDARD_20
    decltype(auto) async_accept(io_context& ctx, use_awaitable_t /*unused*/) {
        async_result<use_awaitable_t, void(error_code, tcp_socket)> result(use_awaitable);
        async_accept(ctx, function<void(error_code, tcp_socket)>(result.get_handler()));
        return result.get();
    }
#endif
};
 // TCP
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_TCP_TCP_ACCEPTOR_HPP__