resolve.hpp

Go to the documentation of this file.

#include <boost/asio/ip/tcp.hpp>
#include <boost/system/error_code.hpp>
 
#include <string>
#include <stdexcept>
#include <algorithm>
#include <vector>
 
namespace Roar::Dns
{
    template <typename Protocol = boost::asio::ip::tcp, typename FunctionT>
    void resolveAll(
        boost::asio::any_io_executor context,
        std::string const& host,
        std::string const& port,
        FunctionT&& onResolveDone,
        boost::asio::ip::resolver_base::flags flags = {})
    {
        using ResolverType = typename Protocol::resolver;
        ResolverType resolver{context};
 
        boost::system::error_code ec;
        const auto start = resolver.resolve(host.c_str(), port.c_str(), flags, ec);
        const auto end = decltype(start){};
 
        if (start == end || ec)
            throw std::runtime_error("Cannot resolve passed host.");
 
        onResolveDone(start, end);
    }
 
    template <typename Protocol = boost::asio::ip::tcp, typename FunctionT>
    void resolveAll(
        boost::asio::any_io_executor context,
        std::string const& host,
        std::string const& port,
        FunctionT&& onResolveDone,
        boost::system::error_code& ec,
        boost::asio::ip::resolver_base::flags flags = {})
    {
        using ResolverType = typename Protocol::resolver;
        ResolverType resolver{context};
 
        const auto start = resolver.resolve(host.c_str(), port.c_str(), flags, ec);
        const auto end = decltype(start){};
 
        if (start == end || ec)
            return;
 
        onResolveDone(start, end);
    }
 
    template <typename Protocol = boost::asio::ip::tcp, typename FunctionT>
    void resolveAll(
        boost::asio::any_io_executor context,
        std::string const& host,
        unsigned short port,
        FunctionT&& onResolveDone,
        boost::system::error_code& ec,
        boost::asio::ip::resolver_base::flags flags = {})
    {
        resolveAll(
            context,
            host,
            port,
            [&onResolveDone](auto begin, auto end) {
                onResolveDone(typename Protocol::resolver::iterator{begin}, typename Protocol::resolver::iterator{end});
            },
            ec,
            flags);
    }
 
    template <typename Protocol = boost::asio::ip::tcp>
    void resolveAll(
        boost::asio::any_io_executor context,
        std::string const& host,
        std::string const& port,
        std::function<void(typename Protocol::resolver::iterator, typename Protocol::resolver::iterator)> onResolveDone,
        boost::asio::ip::resolver_base::flags flags = {})
    {
        resolveAll(
            context,
            host,
            port,
            [&onResolveDone](auto begin, auto end) {
                onResolveDone(typename Protocol::resolver::iterator{begin}, typename Protocol::resolver::iterator{end});
            },
            flags);
    }
 
    template <typename ExecutorType, typename PickerFunctionT, typename Protocol = boost::asio::ip::tcp>
    typename Protocol::resolver::endpoint_type resolveSelect(
        ExecutorType&& executor,
        std::string const& host,
        std::string const& port,
        PickerFunctionT&& picker,
        boost::asio::ip::resolver_base::flags flags = {})
    {
        using ResolverType = typename Protocol::resolver;
        ResolverType resolver{executor};
 
        boost::system::error_code ec;
        typename ResolverType::iterator end, start = resolver.resolve(host.c_str(), port.c_str(), flags, ec);
        std::vector<typename ResolverType::endpoint_type> endpoints(start, end);
 
        if (endpoints.empty())
            throw std::runtime_error("Cannot resolve passed host.");
 
        return picker(endpoints);
    }
 
    template <typename ExecutorType, typename PickerFunctionT, typename Protocol = boost::asio::ip::tcp>
    typename Protocol::resolver::endpoint_type resolveSelect(
        ExecutorType&& executor,
        std::string const& host,
        unsigned short port,
        PickerFunctionT&& picker,
        boost::asio::ip::resolver_base::flags flags = {})
    {
        return resolve<ExecutorType, PickerFunctionT, Protocol>(
            std::forward<ExecutorType>(executor),
            host,
            std::to_string(port),
            std::forward<PickerFunctionT>(picker),
            flags);
    }
 
    template <typename ExecutorType, typename Protocol = boost::asio::ip::tcp>
    typename Protocol::resolver::endpoint_type resolveSingle(
        ExecutorType&& executor,
        std::string const& host,
        std::string const& port,
        bool preferIpv4 = false,
        boost::asio::ip::resolver_base::flags flags = {})
    {
        return resolveSelect(
            std::forward<ExecutorType>(executor),
            host,
            port,
            [&preferIpv4](auto& endpoints) {
                std::partition(std::begin(endpoints), std::end(endpoints), [preferIpv4](auto const& lhs) {
                    return lhs.address().is_v4() == preferIpv4;
                });
                return endpoints[0];
            },
            flags);
    }
 
    template <typename ExecutorType, typename Protocol = boost::asio::ip::tcp>
    typename Protocol::resolver::endpoint_type resolveSingle(
        ExecutorType&& executor,
        std::string const& host,
        unsigned short port,
        bool preferIpv4 = false,
        boost::asio::ip::resolver_base::flags flags = {})
    {
        return resolveSingle<ExecutorType, Protocol>(
            std::forward<ExecutorType>(executor), host, std::to_string(port), preferIpv4, flags);
    }
}