IPEndpoint.h

#pragma once
 
#include <xrpl/beast/hash/hash_append.h>
#include <xrpl/beast/hash/uhash.h>
#include <xrpl/beast/net/IPAddress.h>
#include <xrpl/beast/net/IPAddressV4.h>
#include <xrpl/beast/net/IPAddressV6.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <istream>
#include <optional>
#include <string>
 
namespace beast::ip {
 
using Port = std::uint16_t;

class Endpoint
{
public:
    Endpoint();

    explicit Endpoint(Address addr, Port port = 0);

    static std::optional<Endpoint>
    fromStringChecked(std::string const& s);
    static Endpoint
    fromString(std::string const& s);

    [[nodiscard]] std::string
    toString() const;

    [[nodiscard]] Port
    port() const
    {
        return port_;
    }

    [[nodiscard]] Endpoint
    atPort(Port port) const
    {
        return Endpoint(addr_, port);
    }

    [[nodiscard]] Address const&
    address() const
    {
        return addr_;
    }

    [[nodiscard]] bool
    isV4() const
    {
        return addr_.is_v4();
    }
    [[nodiscard]] bool
    isV6() const
    {
        return addr_.is_v6();
    }
    [[nodiscard]] AddressV4
    toV4() const
    {
        return addr_.to_v4();
    }
    [[nodiscard]] AddressV6
    toV6() const
    {
        return addr_.to_v6();
    }


    friend bool
    operator==(Endpoint const& lhs, Endpoint const& rhs);
    friend bool
    operator<(Endpoint const& lhs, Endpoint const& rhs);
    friend bool
    operator>(Endpoint const& lhs, Endpoint const& rhs)
    {
        return rhs < lhs;
    }
    friend bool
    operator<=(Endpoint const& lhs, Endpoint const& rhs)
    {
        return !(lhs > rhs);
    }
    friend bool
    operator>=(Endpoint const& lhs, Endpoint const& rhs)
    {
        return !(rhs > lhs);
    }

 
    template <class Hasher>
    friend void
    hash_append(Hasher& h, Endpoint const& endpoint)
    {
        using ::beast::hash_append;
        hash_append(h, endpoint.addr_, endpoint.port_);
    }
 
private:
    Address addr_;
    Port port_;
};
 
//------------------------------------------------------------------------------
 
// Properties

inline bool
isLoopback(Endpoint const& endpoint)
{
    return isLoopback(endpoint.address());
}

inline bool
isUnspecified(Endpoint const& endpoint)
{
    return isUnspecified(endpoint.address());
}

inline bool
isMulticast(Endpoint const& endpoint)
{
    return isMulticast(endpoint.address());
}

inline bool
isPrivate(Endpoint const& endpoint)
{
    return isPrivate(endpoint.address());
}

inline bool
isPublic(Endpoint const& endpoint)
{
    return isPublic(endpoint.address());
}
 
//------------------------------------------------------------------------------

inline std::string
to_string(Endpoint const& endpoint)
{
    return endpoint.toString();
}

template <typename OutputStream>
OutputStream&
operator<<(OutputStream& os, Endpoint const& endpoint)
{
    os << to_string(endpoint);
    return os;
}

std::istream&
operator>>(std::istream& is, Endpoint& endpoint);
 
}  // namespace beast::ip
 
//------------------------------------------------------------------------------
 
namespace std {
template <>
struct hash<::beast::ip::Endpoint>
{
    hash() = default;
 
    std::size_t
    operator()(::beast::ip::Endpoint const& endpoint) const
    {
        return ::beast::Uhash<>{}(endpoint);
    }
};
}  // namespace std
 
namespace boost {
template <>
struct hash<::beast::ip::Endpoint>
{
    hash() = default;
 
    std::size_t
    operator()(::beast::ip::Endpoint const& endpoint) const
    {
        return ::beast::Uhash<>{}(endpoint);
    }
};
}  // namespace boost