endpoint.hpp

#pragma once
 
#include "fly/fly.hpp"
#include "fly/net/ipv4_address.hpp"
#include "fly/net/ipv6_address.hpp"
#include "fly/net/socket/concepts.hpp"
#include "fly/net/socket/types.hpp"
#include "fly/types/string/lexer.hpp"
#include "fly/types/string/string.hpp"
 
#include <compare>
#include <limits>
#include <optional>
#include <string>
#include <type_traits>
 
namespace fly::net {
 
template <IPAddress IPAddressType>
class Endpoint
{
public:
    using address_type = IPAddressType;
 
    Endpoint() = default;
 
    constexpr Endpoint(const IPAddressType &address, port_type port) noexcept;
 
    constexpr Endpoint(IPAddressType &&address, port_type port) noexcept;
 
    Endpoint(const Endpoint &) = default;
    Endpoint(Endpoint &&) = default;
 
    Endpoint &operator=(const Endpoint &) = default;
    Endpoint &operator=(Endpoint &&) = default;
 
    static constexpr bool is_ipv4();
 
    static constexpr bool is_ipv6();
 
    static constexpr std::optional<Endpoint> from_string(std::string_view endpoint);
 
    constexpr const IPAddressType &address() const;
 
    constexpr port_type port() const;
 
#if defined(FLY_MACOS)
    constexpr bool operator==(const Endpoint &endpoint) const;
    constexpr bool operator!=(const Endpoint &endpoint) const;
    constexpr bool operator<(const Endpoint &endpoint) const;
    constexpr bool operator<=(const Endpoint &endpoint) const;
    constexpr bool operator>(const Endpoint &endpoint) const;
    constexpr bool operator>=(const Endpoint &endpoint) const;
#else
    auto operator<=>(const Endpoint &) const = default;
#endif
 
private:
    IPAddressType m_address {};
    port_type m_port {0};
};
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr Endpoint<IPAddressType>::Endpoint(const IPAddressType &address, port_type port) noexcept :
    m_address(address),
    m_port(port)
{
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr Endpoint<IPAddressType>::Endpoint(IPAddressType &&address, port_type port) noexcept :
    m_address(address),
    m_port(port)
{
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr bool Endpoint<IPAddressType>::is_ipv4()
{
    return std::is_same_v<IPAddressType, IPv4Address>;
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr bool Endpoint<IPAddressType>::is_ipv6()
{
    return std::is_same_v<IPAddressType, IPv6Address>;
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr std::optional<Endpoint<IPAddressType>>
Endpoint<IPAddressType>::from_string(std::string_view endpoint)
{
    constexpr const auto s_max16 =
        static_cast<std::size_t>(std::numeric_limits<std::uint16_t>::max());
    constexpr const auto s_colon = ':';
 
    const std::size_t separator = endpoint.find_last_of(s_colon);
 
    if ((separator == std::string_view::npos) || (separator == 0) || (separator == endpoint.size()))
    {
        return std::nullopt;
    }
 
    auto address_view = endpoint.substr(0, separator);
    auto port_view = endpoint.substr(separator + 1);
 
    if constexpr (is_ipv6())
    {
        constexpr const auto s_left_bracket = '[';
        constexpr const auto s_right_bracket = ']';
 
        if (address_view.starts_with(s_left_bracket) && address_view.ends_with(s_right_bracket))
        {
            address_view = address_view.substr(1, address_view.size() - 2);
        }
        else
        {
            return std::nullopt;
        }
    }
 
    fly::Lexer lexer(std::move(port_view));
 
    auto address = IPAddressType::from_string(std::move(address_view));
    auto port = lexer.consume_number();
 
    if (!address || !port || (*port > s_max16) || lexer.peek())
    {
        return std::nullopt;
    }
 
    return Endpoint(*std::move(address), static_cast<port_type>(*port));
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr const IPAddressType &Endpoint<IPAddressType>::address() const
{
    return m_address;
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr port_type Endpoint<IPAddressType>::port() const
{
    return m_port;
}
 
#if defined(FLY_MACOS)
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr bool Endpoint<IPAddressType>::operator==(const Endpoint<IPAddressType> &endpoint) const
{
    return (m_address == endpoint.m_address) && (m_port == endpoint.m_port);
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr bool Endpoint<IPAddressType>::operator!=(const Endpoint<IPAddressType> &endpoint) const
{
    return !(*this == endpoint);
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr bool Endpoint<IPAddressType>::operator<(const Endpoint<IPAddressType> &endpoint) const
{
    if (m_address < endpoint.m_address)
    {
        return true;
    }
 
    return m_port < endpoint.m_port;
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr bool Endpoint<IPAddressType>::operator<=(const Endpoint<IPAddressType> &endpoint) const
{
    return !(endpoint < *this);
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr bool Endpoint<IPAddressType>::operator>(const Endpoint<IPAddressType> &endpoint) const
{
    return !(*this <= endpoint);
}
 
//==================================================================================================
template <IPAddress IPAddressType>
constexpr bool Endpoint<IPAddressType>::operator>=(const Endpoint<IPAddressType> &endpoint) const
{
    return !(*this < endpoint);
}
 
#endif
 
} // namespace fly::net
 
//==================================================================================================
template <>
struct fly::Formatter<fly::net::Endpoint<fly::net::IPv4Address>>
{
    template <typename FormatContext>
    void format(const fly::net::Endpoint<fly::net::IPv4Address> &endpoint, FormatContext &context)
    {
        fly::String::format_to(context.out(), "{}:{}", endpoint.address(), endpoint.port());
    }
};
 
//==================================================================================================
template <>
struct fly::Formatter<fly::net::Endpoint<fly::net::IPv6Address>>
{
    template <typename FormatContext>
    void format(const fly::net::Endpoint<fly::net::IPv6Address> &endpoint, FormatContext &context)
    {
        fly::String::format_to(context.out(), "[{}]:{}", endpoint.address(), endpoint.port());
    }
};