net.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <array>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
namespace idfxx::net {
 
class ip4_addr {
public:
    [[nodiscard]] static std::optional<ip4_addr> parse(std::string_view s) noexcept;
 
    constexpr ip4_addr() noexcept = default;
 
    constexpr explicit ip4_addr(uint32_t addr) noexcept
        : _addr(addr) {}
 
    constexpr ip4_addr(uint8_t a, uint8_t b, uint8_t c, uint8_t d) noexcept
        : _addr(
              static_cast<uint32_t>(a) | (static_cast<uint32_t>(b) << 8) | (static_cast<uint32_t>(c) << 16) |
              (static_cast<uint32_t>(d) << 24)
          ) {}
 
    [[nodiscard]] constexpr uint32_t addr() const noexcept { return _addr; }
 
    [[nodiscard]] constexpr bool is_any() const noexcept { return _addr == 0; }
 
    [[nodiscard]] constexpr bool operator==(const ip4_addr&) const noexcept = default;
 
private:
    uint32_t _addr = 0;
};
 
class ip6_addr {
public:
    [[nodiscard]] static std::optional<ip6_addr> parse(std::string_view s) noexcept;
 
    constexpr ip6_addr() noexcept = default;
 
    constexpr explicit ip6_addr(std::array<uint32_t, 4> words, uint8_t zone = 0) noexcept
        : _addr(words)
        , _zone(zone) {}
 
    [[nodiscard]] constexpr const std::array<uint32_t, 4>& addr() const noexcept { return _addr; }
 
    [[nodiscard]] constexpr uint8_t zone() const noexcept { return _zone; }
 
    [[nodiscard]] constexpr bool is_any() const noexcept {
        return _addr[0] == 0 && _addr[1] == 0 && _addr[2] == 0 && _addr[3] == 0;
    }
 
    [[nodiscard]] constexpr bool operator==(const ip6_addr&) const noexcept = default;
 
private:
    std::array<uint32_t, 4> _addr = {};
    uint8_t _zone = 0;
};
 
struct ip4_info {
    ip4_addr ip;      
    ip4_addr netmask; 
    ip4_addr gateway; 
    [[nodiscard]] constexpr bool operator==(const ip4_info&) const noexcept = default;
};
 
struct ip6_info {
    ip6_addr ip; 
};
 
} // namespace idfxx::net
 
// =============================================================================
// String conversions (in idfxx namespace)
// =============================================================================
 
namespace idfxx {
 
[[nodiscard]] std::string to_string(net::ip4_addr addr);
 
[[nodiscard]] std::string to_string(net::ip6_addr addr);
 
[[nodiscard]] std::string to_string(net::ip4_info info);
 
} // namespace idfxx
 
#include "sdkconfig.h"
#ifdef CONFIG_IDFXX_STD_FORMAT
#include <algorithm>
#include <format>
namespace std {
 
template<>
struct formatter<idfxx::net::ip4_addr> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::net::ip4_addr addr, FormatContext& ctx) const {
        auto s = idfxx::to_string(addr);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
 
template<>
struct formatter<idfxx::net::ip6_addr> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::net::ip6_addr addr, FormatContext& ctx) const {
        auto s = idfxx::to_string(addr);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
 
template<>
struct formatter<idfxx::net::ip4_info> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::net::ip4_info info, FormatContext& ctx) const {
        auto s = idfxx::to_string(info);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
 
} // namespace std
#endif // CONFIG_IDFXX_STD_FORMAT