ipv6_address.hpp

/*
 * Copyright (c) 2024 The RefValue Project
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#pragma once
 
#include "../abi/string.hpp"
#include "../compat.hpp"
 
#include <algorithm>
#include <array>
#include <compare>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <optional>
#include <span>
#include <string_view>
 
namespace essence::net {
    class ipv6_address {
    public:
        static constexpr std::size_t value_size        = 16;
        static constexpr std::size_t value_group_count = value_size / 2;
        static constexpr std::size_t max_zone_id_size = 16;
 
        using value_type   = std::array<std::uint8_t, value_size>;
        using zone_id_type = std::array<char, max_zone_id_size>;
 
        constexpr ipv6_address() noexcept : value_{}, zone_id_{} {}
 
 
        constexpr ipv6_address(std::initializer_list<std::uint8_t> address, std::string_view zone_id = "") noexcept
            : ipv6_address{
                  std::span<const std::uint8_t, value_size>{address.begin(), std::min(address.size(), value_size)},
                  zone_id} {}
 
        constexpr explicit ipv6_address(
            std::span<const std::uint8_t, value_size> address, std::string_view zone_id = "") noexcept
            : ipv6_address{} {
            std::ranges::copy(address, value_.begin());
            set_zone_id(zone_id);
        }
 
        constexpr auto operator<=>(const ipv6_address&) const noexcept = default;
 
        [[nodiscard]] constexpr value_type& get() noexcept {
            return value_;
        }
 
        [[nodiscard]] constexpr const value_type& get() const noexcept {
            return value_;
        }
 
        [[nodiscard]] constexpr const char* zone_id() const noexcept {
            return zone_id_.data();
        }
 
        constexpr void set_zone_id(std::string_view zone_id) noexcept {
            zone_id.copy(zone_id_.data(), std::min(zone_id_.size(), zone_id.size()));
        }
 
    private:
        value_type value_;
        zone_id_type zone_id_;
    };
 
    ES_API(CPPESSENCE) std::optional<ipv6_address> parse_ipv6_address(std::string_view str);
 
    template <std::same_as<ipv6_address> T>
    std::optional<T> from_string(std::string_view str) {
        return parse_ipv6_address(str);
    }
 
    ES_API(CPPESSENCE) abi::string to_string(const ipv6_address& address);
} // namespace essence::net