endpoint.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/net>
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
 
namespace idfxx::net {
 
enum class address_family : int {
    ipv4 = 2,  
    ipv6 = 10, 
};
 
enum class ip_protocol : uint8_t {
    icmp = 1,       
    igmp = 2,       
    tcp = 6,        
    udp = 17,       
    icmpv6 = 58,    
    udp_lite = 136, 
};
 
using port_number = uint16_t;
 
enum class direction : int {
    receive, 
    send,    
};
 
enum class dscp : uint8_t {
    default_ = 0, 
 
    // Class selectors (RFC 2474 §4.2.2 — backwards-compat with legacy IP precedence).
    cs1 = 8,
    cs2 = 16,
    cs3 = 24,
    cs4 = 32,
    cs5 = 40,
    cs6 = 48,
    cs7 = 56,
 
    // Assured forwarding (RFC 2597).
    af11 = 10,
    af12 = 12,
    af13 = 14,
    af21 = 18,
    af22 = 20,
    af23 = 22,
    af31 = 26,
    af32 = 28,
    af33 = 30,
    af41 = 34,
    af42 = 36,
    af43 = 38,
 
    voice_admit = 44, 
    ef = 46,          
};
 
class endpoint {
public:
    constexpr endpoint(ipv4_addr addr, port_number port) noexcept
        : _ep(std::pair<ipv4_addr, port_number>{addr, port}) {}
 
    constexpr endpoint(ipv6_addr addr, port_number port) noexcept
        : _ep(std::pair<ipv6_addr, port_number>{addr, port}) {}
 
    [[nodiscard]] static std::optional<endpoint> parse(std::string_view s) noexcept;
 
    [[nodiscard]] constexpr address_family family() const noexcept {
        if (std::holds_alternative<std::pair<ipv4_addr, port_number>>(_ep)) {
            return address_family::ipv4;
        }
        return address_family::ipv6;
    }
 
    [[nodiscard]] constexpr port_number port() const noexcept {
        return std::visit([](const auto& p) { return p.second; }, _ep);
    }
 
    template<ip_address T>
    [[nodiscard]] constexpr std::optional<T> address() const noexcept {
        if (auto* p = std::get_if<std::pair<T, port_number>>(&_ep)) {
            return p->first;
        }
        return std::nullopt;
    }
 
    [[nodiscard]] constexpr bool operator==(const endpoint&) const noexcept = default;
 
private:
    std::variant<std::pair<ipv4_addr, port_number>, std::pair<ipv6_addr, port_number>> _ep;
};
 
struct datagram {
    std::span<std::byte> data; 
    endpoint from;             
    bool truncated = false;
};
 
} // namespace idfxx::net
 
namespace idfxx {
 
[[nodiscard]] std::string to_string(const net::endpoint& ep);
 
} // namespace idfxx
 
#include "sdkconfig.h"
#ifdef CONFIG_IDFXX_STD_FORMAT
#include <format>
#include <string_view>
namespace std {
 
// Composes std::formatter<std::string_view> so that the standard fill, align,
// width, and precision spec all work on an endpoint:
//   std::format("{}",        ep) -> "1.2.3.4:8080"
//   std::format("{:>30}",    ep) -> right-aligned to width 30
//   std::format("{:*^25}",   ep) -> center-padded with '*' to width 25
template<>
struct formatter<idfxx::net::endpoint> {
    std::formatter<std::string_view> _underlying;
 
    constexpr auto parse(format_parse_context& ctx) { return _underlying.parse(ctx); }
 
    template<typename FormatContext>
    auto format(const idfxx::net::endpoint& ep, FormatContext& ctx) const {
        return _underlying.format(idfxx::to_string(ep), ctx);
    }
};
 
} // namespace std
#endif // CONFIG_IDFXX_STD_FORMAT