ipv4_address.hpp

#pragma once
 
#include "fly/types/numeric/endian.hpp"
#include "fly/types/string/lexer.hpp"
#include "fly/types/string/string.hpp"
 
#include <array>
#include <compare>
#include <cstdint>
#include <limits>
#include <optional>
#include <string>
 
namespace fly::net {
 
class IPv4Address
{
public:
    using address_type = std::array<std::uint8_t, 4>;
    using int_type = std::uint32_t;
 
    IPv4Address() = default;
 
    explicit constexpr IPv4Address(const address_type &address) noexcept;
 
    explicit constexpr IPv4Address(int_type address) noexcept;
 
    IPv4Address(const IPv4Address &) = default;
    IPv4Address(IPv4Address &&) = default;
 
    IPv4Address &operator=(const IPv4Address &) = default;
    IPv4Address &operator=(IPv4Address &&) = default;
 
    static constexpr IPv4Address in_addr_any();
 
    static constexpr IPv4Address in_addr_broadcast();
 
    static constexpr IPv4Address in_addr_loopback();
 
    static constexpr std::optional<IPv4Address> from_string(std::string_view address);
 
    constexpr int_type network_order() const;
 
    constexpr int_type host_order() const;
 
    auto operator<=>(const IPv4Address &) const = default;
 
private:
    int_type m_address {0};
};
 
//==================================================================================================
constexpr IPv4Address::IPv4Address(const address_type &address) noexcept
{
    m_address |= static_cast<int_type>(address[0]);
    m_address |= static_cast<int_type>(address[1] << 8);
    m_address |= static_cast<int_type>(address[2] << 16);
    m_address |= static_cast<int_type>(address[3] << 24);
}
 
//==================================================================================================
constexpr IPv4Address::IPv4Address(int_type address) noexcept : m_address(address)
{
}
 
//==================================================================================================
constexpr IPv4Address IPv4Address::in_addr_any()
{
    return IPv4Address(0x00'00'00'00);
}
 
//==================================================================================================
constexpr IPv4Address IPv4Address::in_addr_broadcast()
{
    return IPv4Address(0xff'ff'ff'ff);
}
 
//==================================================================================================
constexpr IPv4Address IPv4Address::in_addr_loopback()
{
    return IPv4Address(0x01'00'00'7f);
}
 
//==================================================================================================
constexpr std::optional<IPv4Address> IPv4Address::from_string(std::string_view address)
{
    constexpr const auto s_max32 = static_cast<std::uint64_t>(std::numeric_limits<int_type>::max());
    constexpr const auto s_decimal = '.';
 
    fly::Lexer lexer(std::move(address));
 
    std::array<int_type, 4> parts {};
    std::size_t index = 0;
 
    do
    {
        if (const auto segment = lexer.consume_number(); segment && (*segment <= s_max32))
        {
            parts[index++] = static_cast<int_type>(*segment);
        }
        else
        {
            return std::nullopt;
        }
    } while ((index < parts.size()) && lexer.consume_if(s_decimal));
 
    std::optional<int_type> host_address;
 
    if (index == 1)
    {
        host_address = parts[0];
    }
    else if (index == 2)
    {
        if ((parts[0] <= 0xff) && (parts[1] <= 0xff'ff'ff))
        {
            host_address = (parts[0] << 24) | parts[1];
        }
    }
    else if (index == 3)
    {
        if ((parts[0] <= 0xff) && (parts[1] <= 0xff) && (parts[2] <= 0xff'ff))
        {
            host_address = (parts[0] << 24) | (parts[1] << 16) | parts[2];
        }
    }
    else if (index == 4)
    {
        if ((parts[0] <= 0xff) && (parts[1] <= 0xff) && (parts[2] <= 0xff) && (parts[3] <= 0xff))
        {
            host_address = (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3];
        }
    }
 
    if (!host_address || lexer.peek())
    {
        return std::nullopt;
    }
 
    return IPv4Address(fly::endian_swap_if_non_native<std::endian::big>(*host_address));
}
 
//==================================================================================================
constexpr auto IPv4Address::network_order() const -> int_type
{
    return m_address;
}
 
//==================================================================================================
constexpr auto IPv4Address::host_order() const -> int_type
{
    return fly::endian_swap_if_non_native<std::endian::big>(m_address);
}
 
} // namespace fly::net
 
//==================================================================================================
template <>
struct fly::Formatter<fly::net::IPv4Address>
{
    template <typename FormatContext>
    void format(const fly::net::IPv4Address &address, FormatContext &context)
    {
        const auto network_order = address.network_order();
 
        fly::String::format_to(
            context.out(),
            "{}.{}.{}.{}",
            network_order & 0xff,
            (network_order >> 8) & 0xff,
            (network_order >> 16) & 0xff,
            (network_order >> 24) & 0xff);
    }
};