resolver.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/net/endpoint>
#include <idfxx/net/error>
 
#include <memory>
#include <optional>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace idfxx::net {
 
struct resolver_options {
    std::optional<address_family> family = std::nullopt;
 
    bool numeric_host = false;
 
    bool numeric_port = false;
 
    bool passive = false;
 
    std::optional<ip_protocol> protocol = std::nullopt;
};
 
namespace detail {
 
// Type-erased iteration over resolution results. `sink` is invoked for each
// resolved endpoint; returning false stops iteration early. The sink stopping
// early is not an error — the returned result reflects only the resolution
// itself. Backing the templated `resolve_each` keeps the lwIP-facing code
// out of the public header while preserving zero-allocation iteration.
[[nodiscard]] result<void> resolve_for_each(
    std::string_view host,
    port_number port,
    const resolver_options& opts,
    bool (*sink)(void* ctx, const endpoint&),
    void* ctx
);
[[nodiscard]] result<void> resolve_for_each(
    std::string_view host,
    std::string_view service,
    const resolver_options& opts,
    bool (*sink)(void* ctx, const endpoint&),
    void* ctx
);
 
template<typename F>
bool invoke_resolve_sink(void* ctx, const endpoint& ep) {
    F& fn = *static_cast<F*>(ctx);
    if constexpr (std::is_void_v<std::invoke_result_t<F&, const endpoint&>>) {
        fn(ep);
        return true;
    } else {
        return fn(ep);
    }
}
 
} // namespace detail
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
[[nodiscard]] endpoint resolve_one(std::string_view host, port_number port, const resolver_options& opts = {});
#endif
 
[[nodiscard]] result<endpoint>
try_resolve_one(std::string_view host, port_number port, const resolver_options& opts = {});
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
[[nodiscard]] endpoint resolve_one(std::string_view host, std::string_view service, const resolver_options& opts = {});
#endif
 
[[nodiscard]] result<endpoint>
try_resolve_one(std::string_view host, std::string_view service, const resolver_options& opts = {});
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
template<typename F>
void resolve_each(std::string_view host, port_number port, F&& f, const resolver_options& opts = {}) {
    idfxx::unwrap(try_resolve_each(host, port, std::forward<F>(f), opts));
}
#endif
 
template<typename F>
[[nodiscard]] result<void>
try_resolve_each(std::string_view host, port_number port, F&& f, const resolver_options& opts = {}) {
    using fn_type = std::remove_reference_t<F>;
    return detail::resolve_for_each(host, port, opts, &detail::invoke_resolve_sink<fn_type>, std::addressof(f));
}
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
template<typename F>
void resolve_each(std::string_view host, std::string_view service, F&& f, const resolver_options& opts = {}) {
    idfxx::unwrap(try_resolve_each(host, service, std::forward<F>(f), opts));
}
#endif
 
template<typename F>
[[nodiscard]] result<void>
try_resolve_each(std::string_view host, std::string_view service, F&& f, const resolver_options& opts = {}) {
    using fn_type = std::remove_reference_t<F>;
    return detail::resolve_for_each(host, service, opts, &detail::invoke_resolve_sink<fn_type>, std::addressof(f));
}
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
[[nodiscard]] std::vector<endpoint> resolve(std::string_view host, port_number port, const resolver_options& opts = {});
#endif
 
[[nodiscard]] result<std::vector<endpoint>>
try_resolve(std::string_view host, port_number port, const resolver_options& opts = {});
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
[[nodiscard]] std::vector<endpoint>
resolve(std::string_view host, std::string_view service, const resolver_options& opts = {});
#endif
 
[[nodiscard]] result<std::vector<endpoint>>
try_resolve(std::string_view host, std::string_view service, const resolver_options& opts = {});
 
} // namespace idfxx::net