ip_address.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_UTIL_IP_ADDRESS_HPP__
#define NEFORCE_NETWORK_UTIL_IP_ADDRESS_HPP__

 
#include "NeForce/core/async/async_result.hpp"
#include "NeForce/core/interface/istringify.hpp"
#include "NeForce/core/utility/optional.hpp"
#include "NeForce/core/utility/variant.hpp"
#include "NeForce/network/util/ports.hpp"
#ifdef NEFORCE_PLATFORM_WINDOWS
#    include <ws2tcpip.h>
#    ifdef max
#        undef max
#    endif
#    ifdef min
#        undef min
#    endif
#endif
#ifdef NEFORCE_PLATFORM_LINUX
#    include <netinet/in.h>
#endif
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API ip_address : public istringify<ip_address> {
public:
    using address_type = variant<none_t, ::sockaddr_in, ::sockaddr_in6>; 

    enum class family : int32_t {
        UNDEF = AF_UNSPEC, 
        UNIX = AF_UNIX,    
        INET4 = AF_INET,   
        INET6 = AF_INET6,  
#ifdef NEFORCE_PLATFORM_LINUX
        PACKET = AF_PACKET,       
        NETLINK = AF_NETLINK,     
        BLUETOOTH = AF_BLUETOOTH, 
        CAN = AF_CAN,             
        ALG = AF_ALG,             
        VSOCK = AF_VSOCK,         
        NFC = AF_NFC,             
        XDP = AF_XDP,             
#endif
    };
 
private:
    address_type addr_; 
 
public:
    ip_address() noexcept = default;

    explicit ip_address(const ::sockaddr_in& addr4) noexcept :
    addr_(addr4) {}

    explicit ip_address(const ::sockaddr_in6& addr6) noexcept :
    addr_(addr6) {}
 
    ip_address(const ip_address& other) noexcept = default;
    ip_address& operator=(const ip_address& other) noexcept = default;
 
    ip_address(ip_address&& other) noexcept = default;
    ip_address& operator=(ip_address&& other) noexcept = default;

    NEFORCE_NODISCARD bool is_valid() const noexcept { return !addr_.holds_alternative<none_t>(); }

    NEFORCE_NODISCARD bool is_ipv4() const noexcept { return addr_.holds_alternative<::sockaddr_in>(); }

    NEFORCE_NODISCARD bool is_ipv6() const noexcept { return addr_.holds_alternative<::sockaddr_in6>(); }

    NEFORCE_NODISCARD static ip_address any(ports port = ports::UNDEF, family f = family::INET4) noexcept;

    NEFORCE_NODISCARD static ip_address loopback(ports port = ports::UNDEF, family f = family::INET4) noexcept;

    NEFORCE_NODISCARD const ::sockaddr* data() const noexcept;

    NEFORCE_NODISCARD ::sockaddr* data() noexcept;

    NEFORCE_NODISCARD int size() const noexcept;

    NEFORCE_NODISCARD const address_type& address() const noexcept { return addr_; }

    NEFORCE_NODISCARD family address_family() const noexcept;

    NEFORCE_NODISCARD ports port() const noexcept;

    NEFORCE_NODISCARD string to_string() const;

    NEFORCE_NODISCARD static optional<ip_address> parse(const string& host, ports port = ports{}) noexcept;

    NEFORCE_NODISCARD bool operator==(const ip_address& other) const;

    NEFORCE_NODISCARD bool operator!=(const ip_address& other) const { return !(*this == other); }
};
 // NetworkUtil
 
NEFORCE_BEGIN_INNER__
 
template <>
struct future_handler<error_code, size_t, ip_address> {
    shared_ptr<promise<pair<size_t, ip_address>>> promise_;
 
    void operator()(error_code ec, size_t n, ip_address addr) {
        if (ec) {
            promise_->set_exception(_NEFORCE make_exception_ptr(system_exception(ec)));
        } else {
            promise_->set_value(make_pair(n, move(addr)));
        }
    }
};
 
NEFORCE_END_INNER__
 
template <>
struct async_result<use_future_t, void(error_code, size_t, ip_address)> {
    using handler_type = inner::future_handler<error_code, size_t, ip_address>;
    using return_type = future<pair<size_t, ip_address>>;
    handler_type handler_;
    explicit async_result(use_future_t /*unused*/) {
        handler_.promise_ = make_shared<promise<pair<size_t, ip_address>>>();
    }
    handler_type get_handler() { return handler_; }
    return_type get() { return handler_.promise_->get_future(); }
};
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_UTIL_IP_ADDRESS_HPP__