ipv6_address.hpp

#pragma once
 
#include "fly/fly.hpp"
#include "fly/types/string/lexer.hpp"
#include "fly/types/string/string.hpp"
 
#include <algorithm>
#include <array>
#include <compare>
#include <cstdint>
#include <limits>
#include <optional>
#include <string>
 
namespace fly::net {
 
class IPv6Address
{
public:
    using address_type = std::array<std::uint8_t, 16>;
 
    IPv6Address() = default;
 
    explicit constexpr IPv6Address(const address_type &address) noexcept;
 
    explicit constexpr IPv6Address(address_type &&address) noexcept;
 
    explicit constexpr IPv6Address(const address_type::value_type (&address)[16]) noexcept;
 
    IPv6Address(const IPv6Address &) = default;
    IPv6Address(IPv6Address &&) = default;
 
    IPv6Address &operator=(const IPv6Address &) = default;
    IPv6Address &operator=(IPv6Address &&) = default;
 
    static constexpr IPv6Address in_addr_any();
 
    static constexpr IPv6Address in_addr_loopback();
 
    static constexpr std::optional<IPv6Address> from_string(std::string_view address);
 
    constexpr void copy(address_type::value_type (&address)[16]) const;
 
#if defined(FLY_MACOS)
    constexpr bool operator==(const IPv6Address &address) const;
    constexpr bool operator!=(const IPv6Address &address) const;
    constexpr bool operator<(const IPv6Address &address) const;
    constexpr bool operator<=(const IPv6Address &address) const;
    constexpr bool operator>(const IPv6Address &address) const;
    constexpr bool operator>=(const IPv6Address &address) const;
#else
    auto operator<=>(const IPv6Address &) const = default;
#endif
 
private:
    static constexpr std::size_t s_address_size = std::tuple_size_v<address_type>;
    address_type m_address {};
};
 
//==================================================================================================
constexpr IPv6Address::IPv6Address(const address_type &address) noexcept : m_address {address}
{
}
 
//==================================================================================================
constexpr IPv6Address::IPv6Address(address_type &&address) noexcept : m_address {std::move(address)}
{
}
 
//==================================================================================================
constexpr IPv6Address::IPv6Address(const address_type::value_type (&address)[16]) noexcept
{
    std::copy(std::begin(address), std::end(address), m_address.begin());
}
 
//==================================================================================================
constexpr IPv6Address IPv6Address::in_addr_any()
{
    address_type address {};
    return IPv6Address(std::move(address));
}
 
//==================================================================================================
constexpr IPv6Address IPv6Address::in_addr_loopback()
{
    address_type address {};
    address.back() = 0x01;
 
    return IPv6Address(std::move(address));
}
 
//==================================================================================================
constexpr std::optional<IPv6Address> IPv6Address::from_string(std::string_view address)
{
    constexpr const auto s_max16 =
        static_cast<std::uint64_t>(std::numeric_limits<std::uint16_t>::max());
    constexpr const auto s_colon = ':';
 
    fly::Lexer lexer(std::move(address));
    address_type parts {};
 
    std::optional<std::size_t> index_after_short_form;
    std::size_t index = 0;
 
    do
    {
        if (lexer.consume_if(s_colon))
        {
            if (lexer.consume_if(s_colon))
            {
                if (index_after_short_form)
                {
                    return std::nullopt;
                }
 
                index_after_short_form = index;
            }
        }
        else if (const auto segment = lexer.consume_hex_number(); segment && (*segment <= s_max16))
        {
            parts[index++] = static_cast<address_type::value_type>((*segment >> 8) & 0xff);
            parts[index++] = static_cast<address_type::value_type>(*segment & 0xff);
        }
        else
        {
            return std::nullopt;
        }
    } while (lexer.peek() && (index < s_address_size));
 
    if (lexer.peek() || ((index != s_address_size) && !index_after_short_form))
    {
        return std::nullopt;
    }
    else if (index_after_short_form)
    {
        const auto start = static_cast<std::ptrdiff_t>(s_address_size - index);
        const auto end = static_cast<std::ptrdiff_t>(*index_after_short_form);
 
        std::rotate(parts.rbegin(), parts.rbegin() + start, parts.rend() - end);
    }
 
    return IPv6Address(std::move(parts));
}
 
//==================================================================================================
constexpr void IPv6Address::copy(address_type::value_type (&address)[16]) const
{
    std::copy(m_address.begin(), m_address.end(), std::begin(address));
}
 
#if defined(FLY_MACOS)
 
//==================================================================================================
constexpr bool IPv6Address::operator==(const IPv6Address &address) const
{
    return m_address == address.m_address;
}
 
//==================================================================================================
constexpr bool IPv6Address::operator!=(const IPv6Address &address) const
{
    return m_address != address.m_address;
}
 
//==================================================================================================
constexpr bool IPv6Address::operator<(const IPv6Address &address) const
{
    return m_address < address.m_address;
}
 
//==================================================================================================
constexpr bool IPv6Address::operator<=(const IPv6Address &address) const
{
    return m_address <= address.m_address;
}
 
//==================================================================================================
constexpr bool IPv6Address::operator>(const IPv6Address &address) const
{
    return m_address > address.m_address;
}
 
//==================================================================================================
constexpr bool IPv6Address::operator>=(const IPv6Address &address) const
{
    return m_address >= address.m_address;
}
 
#endif
 
} // namespace fly::net
 
//==================================================================================================
template <>
struct fly::Formatter<fly::net::IPv6Address>
{
    template <typename FormatContext>
    void format(const fly::net::IPv6Address &address, FormatContext &context)
    {
        static constexpr std::size_t s_address_size =
            std::tuple_size_v<fly::net::IPv6Address::address_type>;
 
        fly::net::IPv6Address::address_type::value_type parts[s_address_size] {};
        address.copy(parts);
 
        auto join_segments = [&parts](std::size_t index) -> std::uint16_t {
            return (parts[index] << 8) | parts[index + 1];
        };
 
        bool used_short_form = false;
 
        for (std::size_t i = 0; i < s_address_size;)
        {
            const std::uint16_t segment = join_segments(i);
 
            if ((segment == 0) && !used_short_form)
            {
                do
                {
                    i += 2;
                } while ((i < s_address_size) && (join_segments(i) == 0));
 
                fly::String::format_to(context.out(), "{}", (i < s_address_size) ? ":" : "::");
                used_short_form = true;
            }
            else
            {
                fly::String::format_to(context.out(), "{:.{}}{:x}", ":", (i > 0) ? 1 : 0, segment);
                i += 2;
            }
        }
    }
};