udp_socket.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_UDP_SOCKET_HPP__
#define NEFORCE_NETWORK_UDP_SOCKET_HPP__

 
#include "NeForce/core/async/cancellation_slot.hpp"
#include "NeForce/core/async/use_awaitable.hpp"
#include "NeForce/core/async/io_context.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/memory_view.hpp"
#include "NeForce/network/ip_socket.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API udp_socket final : public ip_socket {
public:
    udp_socket() = default;
 
    udp_socket(udp_socket&&) = default;
    udp_socket& operator=(udp_socket&&) = default;

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

    ssize_t send_to(memory_view<const char> data, const ip_address& endpoint, int flags = 0);

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

    pair<ssize_t, ip_address> receive_from(memory_view<char> buffer, int flags = 0);

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

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

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

    void async_send_to(io_context& ctx, memory_view<const char> data, const ip_address& endpoint,
                       function<void(error_code, size_t)> handler);

    void async_send_to(io_context& ctx, memory_view<const char> data, const ip_address& endpoint,
                       cancellation_slot& slot, function<void(error_code, size_t)> handler);

    template <typename Token,
              enable_if_t<!is_same_v<decay_t<Token>, function<void(error_code, size_t, ip_address)>>, int> = 0>
    void async_receive_from(io_context& ctx, memory_view<char> buffer, Token&& token) {
        async_receive_from(ctx, buffer, function<void(error_code, size_t, ip_address)>(forward<Token>(token)));
    }

    auto async_receive_from(io_context& ctx, memory_view<char> buffer, use_future_t /*unused*/) {
        async_result<use_future_t, void(error_code, size_t, ip_address)> result(use_future);
        async_receive_from(ctx, buffer, function<void(error_code, size_t, ip_address)>(result.get_handler()));
        return result.get();
    }

    void async_receive_from(io_context& ctx, memory_view<char> buffer, detached_t /*unused*/) {
        async_receive_from(ctx, buffer,
                           function<void(error_code, size_t, ip_address)>([](error_code, size_t, ip_address) {}));
    }
 
#ifdef NEFORCE_STANDARD_20
    auto async_receive_from(io_context& ctx, memory_view<char> buffer, use_awaitable_t /*unused*/) {
        async_result<use_awaitable_t, void(error_code, size_t, ip_address)> result(use_awaitable);
        async_receive_from(ctx, buffer, function<void(error_code, size_t, ip_address)>(result.get_handler()));
        return result.get();
    }
#endif

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

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

    void async_send_to(io_context& ctx, memory_view<const char> data, const ip_address& endpoint,
                       detached_t /*unused*/) {
        async_send_to(ctx, data, endpoint, function<void(error_code, size_t)>([](error_code, size_t) {}));
    }
 
#ifdef NEFORCE_STANDARD_20
    auto async_send_to(io_context& ctx, memory_view<const char> data, const ip_address& endpoint,
                       use_awaitable_t /*unused*/) {
        async_result<use_awaitable_t, void(error_code, size_t)> result(use_awaitable);
        async_send_to(ctx, data, endpoint, function<void(error_code, size_t)>(result.get_handler()));
        return result.get();
    }
#endif
};
 // UDP
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_UDP_SOCKET_HPP__