tcp_socket.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_TCP_TCP_SOCKET_HPP__
#define NEFORCE_NETWORK_TCP_TCP_SOCKET_HPP__

 
#include "NeForce/core/async/async_stream.hpp"
#include "NeForce/core/async/cancellation_slot.hpp"
#include "NeForce/core/async/io_context.hpp"
#include "NeForce/core/async/use_awaitable.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/network/ip_socket.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API tcp_socket : public ip_socket, public async_stream {
public:
    tcp_socket() = default;

    tcp_socket(tcp_socket&&) = default;

    tcp_socket& operator=(tcp_socket&&) = default;

    explicit tcp_socket(native_handle_type fd) :
    ip_socket(fd) {}

    ~tcp_socket() override = default;

    void open(family f = family::INET4);

    bool connect(const ip_address& endpoint, milliseconds timeout, bool was_blocking = true);

    virtual ssize_t send(memory_view<const char> data, int flags = 0);

    ssize_t send(memory_view<const char> data, milliseconds timeout, int flags = 0);

    void send_all(memory_view<const char> data);

    virtual ssize_t receive(memory_view<char> buffer, int flags = 0);

    vector<char> receive_all(size_t expected_size);

    NEFORCE_NODISCARD virtual bool is_ssl() const noexcept { return false; }

    void async_connect(io_context& ctx, const ip_address& endpoint, function<void(error_code)> handler);

    void async_connect(io_context& ctx, const ip_address& endpoint, cancellation_slot& slot,
                       function<void(error_code)> handler);

    void async_read(io_context& ctx, memory_view<char> buffer, function<void(error_code, size_t)> handler) override;

    void async_read(io_context& ctx, memory_view<char> buffer, cancellation_slot& slot,
                    function<void(error_code, size_t)> handler) override;

    void async_write(io_context& ctx, memory_view<const char> buffer,
                     function<void(error_code, size_t)> handler) override;

    void async_write(io_context& ctx, memory_view<const char> buffer, cancellation_slot& slot,
                     function<void(error_code, size_t)> handler) override;

    void async_receive(io_context& ctx, memory_view<char> buffer, function<void(error_code, size_t)> handler) {
        async_read(ctx, buffer, move(handler));
    }

    void async_receive(io_context& ctx, memory_view<char> buffer, cancellation_slot& slot,
                       function<void(error_code, size_t)> handler) {
        async_read(ctx, buffer, slot, move(handler));
    }

    void async_send(io_context& ctx, memory_view<const char> buffer, function<void(error_code, size_t)> handler) {
        async_write(ctx, buffer, move(handler));
    }

    void async_send(io_context& ctx, memory_view<const char> buffer, cancellation_slot& slot,
                    function<void(error_code, size_t)> handler) {
        async_write(ctx, buffer, slot, move(handler));
    }

    template <typename Token, enable_if_t<!is_same_v<decay_t<Token>, function<void(error_code, size_t)>>, int> = 0>
    decltype(auto) async_receive(io_context& ctx, memory_view<char> buffer, Token&& token) {
        return async_stream::async_read(ctx, buffer, forward<Token>(token));
    }

    template <typename Token, enable_if_t<!is_same_v<decay_t<Token>, function<void(error_code, size_t)>>, int> = 0>
    decltype(auto) async_send(io_context& ctx, memory_view<const char> buffer, Token&& token) {
        return async_stream::async_write(ctx, buffer, forward<Token>(token));
    }

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

    auto async_connect(io_context& ctx, const ip_address& endpoint, use_future_t /*unused*/) {
        async_result<use_future_t, void(error_code)> result(use_future);
        async_connect(ctx, endpoint, function<void(error_code)>(result.get_handler()));
        return result.get();
    }

    void async_connect(io_context& ctx, const ip_address& endpoint, detached_t /*unused*/) {
        async_connect(ctx, endpoint, function<void(error_code)>([](error_code) {}));
    }
 
#ifdef NEFORCE_STANDARD_20
    auto async_connect(io_context& ctx, const ip_address& endpoint, use_awaitable_t /*unused*/) {
        async_result<use_awaitable_t, void(error_code)> result(use_awaitable);
        async_connect(ctx, endpoint, function<void(error_code)>(result.get_handler()));
        return result.get();
    }
#endif
};
 
 
NEFORCE_BEGIN_INNER__
 
template <>
struct future_handler<error_code, tcp_socket> {
    shared_ptr<promise<tcp_socket>> promise_;
 
    void operator()(error_code ec, tcp_socket sock) {
        if (ec) {
            promise_->set_exception(_NEFORCE make_exception_ptr(system_exception(ec)));
        } else {
            promise_->set_value(move(sock));
        }
    }
};
 
NEFORCE_END_INNER__
 
template <>
struct async_result<use_future_t, void(error_code, tcp_socket)> {
    using handler_type = inner::future_handler<error_code, tcp_socket>;
    using return_type = future<tcp_socket>;
    handler_type handler_;
    explicit async_result(use_future_t /*unused*/) { handler_.promise_ = make_shared<promise<tcp_socket>>(); }
    handler_type get_handler() { return handler_; }
    return_type get() { return handler_.promise_->get_future(); }
};
 // TCP
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_TCP_TCP_SOCKET_HPP__