// Copyright (c) ZeroC, Inc.

// slice2cpp version 3.8.1
// <auto-generated>Generated from Slice file 'Lookup.ice'.</auto-generated>

#define ICE_BUILDING_GENERATED_CODE

#include "IceDiscovery/Lookup.h"
#include <Ice/AsyncResponseHandler.h>
#include <Ice/DefaultSliceLoader.h>
#include <Ice/OutgoingAsync.h>
#include <algorithm>
#include <array>

#if defined(_MSC_VER)
#   pragma warning(disable : 4458) // declaration of ... hides class member
#   pragma warning(disable : 4996) // ... was declared deprecated
#elif defined(__clang__)
#   pragma clang diagnostic ignored "-Wshadow"
#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
#elif defined(__GNUC__)
#   pragma GCC diagnostic ignored "-Wshadow"
#   pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif

#ifndef ICE_DISABLE_VERSION
#   if ICE_INT_VERSION / 100 != 308
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 >= 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 1
#       error Ice patch level mismatch!
#   endif
#endif

IceDiscovery::LookupReplyPrx::~LookupReplyPrx() = default;

void
IceDiscovery::LookupReplyPrx::foundObjectById(const ::Ice::Identity& iceP_id, const std::optional<Ice::ObjectPrx>& iceP_prx, const Ice::Context& context) const
{
    IceInternal::makePromiseOutgoing<void>(true, this, &LookupReplyPrx::_iceI_foundObjectById, iceP_id, iceP_prx, context).get();
}

std::future<void>
IceDiscovery::LookupReplyPrx::foundObjectByIdAsync(const ::Ice::Identity& iceP_id, const std::optional<Ice::ObjectPrx>& iceP_prx, const Ice::Context& context) const
{
    return IceInternal::makePromiseOutgoing<void>(false, this, &LookupReplyPrx::_iceI_foundObjectById, iceP_id, iceP_prx, context);
}

std::function<void()>
IceDiscovery::LookupReplyPrx::foundObjectByIdAsync(const ::Ice::Identity& iceP_id, const std::optional<Ice::ObjectPrx>& iceP_prx, std::function<void()> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
{
    return IceInternal::makeLambdaOutgoing<void>(std::move(response), std::move(exception), std::move(sent), this, &IceDiscovery::LookupReplyPrx::_iceI_foundObjectById, iceP_id, iceP_prx, context);
}

void
IceDiscovery::LookupReplyPrx::_iceI_foundObjectById(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, const ::Ice::Identity& iceP_id, const std::optional<Ice::ObjectPrx>& iceP_prx, const Ice::Context& context) const
{
    static constexpr std::string_view operationName = "foundObjectById";

    outAsync->invoke(
        operationName,
        Ice::OperationMode::Normal,
        std::nullopt,
        context,
        [&](Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_id, iceP_prx);
        },
        nullptr);
}

void
IceDiscovery::LookupReplyPrx::foundAdapterById(std::string_view iceP_id, const std::optional<Ice::ObjectPrx>& iceP_prx, bool iceP_isReplicaGroup, const Ice::Context& context) const
{
    IceInternal::makePromiseOutgoing<void>(true, this, &LookupReplyPrx::_iceI_foundAdapterById, iceP_id, iceP_prx, iceP_isReplicaGroup, context).get();
}

std::future<void>
IceDiscovery::LookupReplyPrx::foundAdapterByIdAsync(std::string_view iceP_id, const std::optional<Ice::ObjectPrx>& iceP_prx, bool iceP_isReplicaGroup, const Ice::Context& context) const
{
    return IceInternal::makePromiseOutgoing<void>(false, this, &LookupReplyPrx::_iceI_foundAdapterById, iceP_id, iceP_prx, iceP_isReplicaGroup, context);
}

std::function<void()>
IceDiscovery::LookupReplyPrx::foundAdapterByIdAsync(std::string_view iceP_id, const std::optional<Ice::ObjectPrx>& iceP_prx, bool iceP_isReplicaGroup, std::function<void()> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
{
    return IceInternal::makeLambdaOutgoing<void>(std::move(response), std::move(exception), std::move(sent), this, &IceDiscovery::LookupReplyPrx::_iceI_foundAdapterById, iceP_id, iceP_prx, iceP_isReplicaGroup, context);
}

void
IceDiscovery::LookupReplyPrx::_iceI_foundAdapterById(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, std::string_view iceP_id, const std::optional<Ice::ObjectPrx>& iceP_prx, bool iceP_isReplicaGroup, const Ice::Context& context) const
{
    static constexpr std::string_view operationName = "foundAdapterById";

    outAsync->invoke(
        operationName,
        Ice::OperationMode::Normal,
        std::nullopt,
        context,
        [&](Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_id, iceP_prx, iceP_isReplicaGroup);
        },
        nullptr);
}

const char*
IceDiscovery::LookupReplyPrx::ice_staticId() noexcept
{
    return "::IceDiscovery::LookupReply";
}

IceDiscovery::LookupPrx::~LookupPrx() = default;

void
IceDiscovery::LookupPrx::findObjectById(std::string_view iceP_domainId, const ::Ice::Identity& iceP_id, const std::optional<LookupReplyPrx>& iceP_reply, const Ice::Context& context) const
{
    IceInternal::makePromiseOutgoing<void>(true, this, &LookupPrx::_iceI_findObjectById, iceP_domainId, iceP_id, iceP_reply, context).get();
}

std::future<void>
IceDiscovery::LookupPrx::findObjectByIdAsync(std::string_view iceP_domainId, const ::Ice::Identity& iceP_id, const std::optional<LookupReplyPrx>& iceP_reply, const Ice::Context& context) const
{
    return IceInternal::makePromiseOutgoing<void>(false, this, &LookupPrx::_iceI_findObjectById, iceP_domainId, iceP_id, iceP_reply, context);
}

std::function<void()>
IceDiscovery::LookupPrx::findObjectByIdAsync(std::string_view iceP_domainId, const ::Ice::Identity& iceP_id, const std::optional<LookupReplyPrx>& iceP_reply, std::function<void()> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
{
    return IceInternal::makeLambdaOutgoing<void>(std::move(response), std::move(exception), std::move(sent), this, &IceDiscovery::LookupPrx::_iceI_findObjectById, iceP_domainId, iceP_id, iceP_reply, context);
}

void
IceDiscovery::LookupPrx::_iceI_findObjectById(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, std::string_view iceP_domainId, const ::Ice::Identity& iceP_id, const std::optional<LookupReplyPrx>& iceP_reply, const Ice::Context& context) const
{
    static constexpr std::string_view operationName = "findObjectById";

    outAsync->invoke(
        operationName,
        Ice::OperationMode::Idempotent,
        std::nullopt,
        context,
        [&](Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_domainId, iceP_id, iceP_reply);
        },
        nullptr);
}

void
IceDiscovery::LookupPrx::findAdapterById(std::string_view iceP_domainId, std::string_view iceP_id, const std::optional<LookupReplyPrx>& iceP_reply, const Ice::Context& context) const
{
    IceInternal::makePromiseOutgoing<void>(true, this, &LookupPrx::_iceI_findAdapterById, iceP_domainId, iceP_id, iceP_reply, context).get();
}

std::future<void>
IceDiscovery::LookupPrx::findAdapterByIdAsync(std::string_view iceP_domainId, std::string_view iceP_id, const std::optional<LookupReplyPrx>& iceP_reply, const Ice::Context& context) const
{
    return IceInternal::makePromiseOutgoing<void>(false, this, &LookupPrx::_iceI_findAdapterById, iceP_domainId, iceP_id, iceP_reply, context);
}

std::function<void()>
IceDiscovery::LookupPrx::findAdapterByIdAsync(std::string_view iceP_domainId, std::string_view iceP_id, const std::optional<LookupReplyPrx>& iceP_reply, std::function<void()> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
{
    return IceInternal::makeLambdaOutgoing<void>(std::move(response), std::move(exception), std::move(sent), this, &IceDiscovery::LookupPrx::_iceI_findAdapterById, iceP_domainId, iceP_id, iceP_reply, context);
}

void
IceDiscovery::LookupPrx::_iceI_findAdapterById(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, std::string_view iceP_domainId, std::string_view iceP_id, const std::optional<LookupReplyPrx>& iceP_reply, const Ice::Context& context) const
{
    static constexpr std::string_view operationName = "findAdapterById";

    outAsync->invoke(
        operationName,
        Ice::OperationMode::Idempotent,
        std::nullopt,
        context,
        [&](Ice::OutputStream* ostr)
        {
            ostr->writeAll(iceP_domainId, iceP_id, iceP_reply);
        },
        nullptr);
}

const char*
IceDiscovery::LookupPrx::ice_staticId() noexcept
{
    return "::IceDiscovery::Lookup";
}

void
IceDiscovery::LookupReply::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
{
    static constexpr std::array<std::string_view, 6> allOperations{"foundAdapterById", "foundObjectById", "ice_id", "ice_ids", "ice_isA", "ice_ping"};

    const Ice::Current& current = request.current();
    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
    if (r.first == r.second)
    {
        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
        return;
    }

    switch (r.first - allOperations.begin())
    {
        case 0:
        {
            _iceD_foundAdapterById(request, std::move(sendResponse));
            break;
        }
        case 1:
        {
            _iceD_foundObjectById(request, std::move(sendResponse));
            break;
        }
        case 2:
        {
            _iceD_ice_id(request, std::move(sendResponse));
            break;
        }
        case 3:
        {
            _iceD_ice_ids(request, std::move(sendResponse));
            break;
        }
        case 4:
        {
            _iceD_ice_isA(request, std::move(sendResponse));
            break;
        }
        case 5:
        {
            _iceD_ice_ping(request, std::move(sendResponse));
            break;
        }
        default:
        {
            assert(false);
            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
        }
    }
}

std::vector<std::string>
IceDiscovery::LookupReply::ice_ids(const Ice::Current&) const
{
    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::IceDiscovery::LookupReply"};
    return allTypeIds;
}

std::string
IceDiscovery::LookupReply::ice_id(const Ice::Current&) const
{
    return std::string{ice_staticId()};
}

void
IceDiscovery::LookupReply::_iceD_foundObjectById(
    Ice::IncomingRequest& request,
    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
{
    checkNonIdempotent(request.current());
    auto istr = &request.inputStream();
    istr->startEncapsulation();
    ::Ice::Identity iceP_id;
    std::optional<Ice::ObjectPrx> iceP_prx;
    istr->readAll(iceP_id, iceP_prx);
    istr->endEncapsulation();
    this->foundObjectById(std::move(iceP_id), std::move(iceP_prx), request.current());
    sendResponse(Ice::makeEmptyOutgoingResponse(request.current()));
}

void
IceDiscovery::LookupReply::_iceD_foundAdapterById(
    Ice::IncomingRequest& request,
    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
{
    checkNonIdempotent(request.current());
    auto istr = &request.inputStream();
    istr->startEncapsulation();
    std::string iceP_id;
    std::optional<Ice::ObjectPrx> iceP_prx;
    bool iceP_isReplicaGroup;
    istr->readAll(iceP_id, iceP_prx, iceP_isReplicaGroup);
    istr->endEncapsulation();
    this->foundAdapterById(std::move(iceP_id), std::move(iceP_prx), iceP_isReplicaGroup, request.current());
    sendResponse(Ice::makeEmptyOutgoingResponse(request.current()));
}

const char*
IceDiscovery::LookupReply::ice_staticId() noexcept
{
    return "::IceDiscovery::LookupReply";
}

void
IceDiscovery::Lookup::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
{
    static constexpr std::array<std::string_view, 6> allOperations{"findAdapterById", "findObjectById", "ice_id", "ice_ids", "ice_isA", "ice_ping"};

    const Ice::Current& current = request.current();
    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
    if (r.first == r.second)
    {
        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
        return;
    }

    switch (r.first - allOperations.begin())
    {
        case 0:
        {
            _iceD_findAdapterById(request, std::move(sendResponse));
            break;
        }
        case 1:
        {
            _iceD_findObjectById(request, std::move(sendResponse));
            break;
        }
        case 2:
        {
            _iceD_ice_id(request, std::move(sendResponse));
            break;
        }
        case 3:
        {
            _iceD_ice_ids(request, std::move(sendResponse));
            break;
        }
        case 4:
        {
            _iceD_ice_isA(request, std::move(sendResponse));
            break;
        }
        case 5:
        {
            _iceD_ice_ping(request, std::move(sendResponse));
            break;
        }
        default:
        {
            assert(false);
            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
        }
    }
}

std::vector<std::string>
IceDiscovery::Lookup::ice_ids(const Ice::Current&) const
{
    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::IceDiscovery::Lookup"};
    return allTypeIds;
}

std::string
IceDiscovery::Lookup::ice_id(const Ice::Current&) const
{
    return std::string{ice_staticId()};
}

void
IceDiscovery::Lookup::_iceD_findObjectById(
    Ice::IncomingRequest& request,
    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
{
    auto istr = &request.inputStream();
    istr->startEncapsulation();
    std::string iceP_domainId;
    ::Ice::Identity iceP_id;
    std::optional<LookupReplyPrx> iceP_reply;
    istr->readAll(iceP_domainId, iceP_id, iceP_reply);
    istr->endEncapsulation();
    this->findObjectById(std::move(iceP_domainId), std::move(iceP_id), std::move(iceP_reply), request.current());
    sendResponse(Ice::makeEmptyOutgoingResponse(request.current()));
}

void
IceDiscovery::Lookup::_iceD_findAdapterById(
    Ice::IncomingRequest& request,
    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
{
    auto istr = &request.inputStream();
    istr->startEncapsulation();
    std::string iceP_domainId;
    std::string iceP_id;
    std::optional<LookupReplyPrx> iceP_reply;
    istr->readAll(iceP_domainId, iceP_id, iceP_reply);
    istr->endEncapsulation();
    this->findAdapterById(std::move(iceP_domainId), std::move(iceP_id), std::move(iceP_reply), request.current());
    sendResponse(Ice::makeEmptyOutgoingResponse(request.current()));
}

const char*
IceDiscovery::Lookup::ice_staticId() noexcept
{
    return "::IceDiscovery::Lookup";
}

void
IceDiscovery::AsyncLookupReply::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
{
    static constexpr std::array<std::string_view, 6> allOperations{"foundAdapterById", "foundObjectById", "ice_id", "ice_ids", "ice_isA", "ice_ping"};

    const Ice::Current& current = request.current();
    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
    if (r.first == r.second)
    {
        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
        return;
    }

    switch (r.first - allOperations.begin())
    {
        case 0:
        {
            _iceD_foundAdapterById(request, std::move(sendResponse));
            break;
        }
        case 1:
        {
            _iceD_foundObjectById(request, std::move(sendResponse));
            break;
        }
        case 2:
        {
            _iceD_ice_id(request, std::move(sendResponse));
            break;
        }
        case 3:
        {
            _iceD_ice_ids(request, std::move(sendResponse));
            break;
        }
        case 4:
        {
            _iceD_ice_isA(request, std::move(sendResponse));
            break;
        }
        case 5:
        {
            _iceD_ice_ping(request, std::move(sendResponse));
            break;
        }
        default:
        {
            assert(false);
            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
        }
    }
}

std::vector<std::string>
IceDiscovery::AsyncLookupReply::ice_ids(const Ice::Current&) const
{
    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::IceDiscovery::LookupReply"};
    return allTypeIds;
}

std::string
IceDiscovery::AsyncLookupReply::ice_id(const Ice::Current&) const
{
    return std::string{ice_staticId()};
}

void
IceDiscovery::AsyncLookupReply::_iceD_foundObjectById(
    Ice::IncomingRequest& request,
    std::function<void(Ice::OutgoingResponse)> sendResponse)
{
    checkNonIdempotent(request.current());
    auto istr = &request.inputStream();
    istr->startEncapsulation();
    ::Ice::Identity iceP_id;
    std::optional<Ice::ObjectPrx> iceP_prx;
    istr->readAll(iceP_id, iceP_prx);
    istr->endEncapsulation();
    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
    try
    {
        this->foundObjectByIdAsync(std::move(iceP_id), std::move(iceP_prx), [responseHandler] { responseHandler->sendEmptyResponse(); }, [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
    }
    catch (...)
    {
        responseHandler->sendException(std::current_exception());
    }
}

void
IceDiscovery::AsyncLookupReply::_iceD_foundAdapterById(
    Ice::IncomingRequest& request,
    std::function<void(Ice::OutgoingResponse)> sendResponse)
{
    checkNonIdempotent(request.current());
    auto istr = &request.inputStream();
    istr->startEncapsulation();
    std::string iceP_id;
    std::optional<Ice::ObjectPrx> iceP_prx;
    bool iceP_isReplicaGroup;
    istr->readAll(iceP_id, iceP_prx, iceP_isReplicaGroup);
    istr->endEncapsulation();
    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
    try
    {
        this->foundAdapterByIdAsync(std::move(iceP_id), std::move(iceP_prx), iceP_isReplicaGroup, [responseHandler] { responseHandler->sendEmptyResponse(); }, [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
    }
    catch (...)
    {
        responseHandler->sendException(std::current_exception());
    }
}

const char*
IceDiscovery::AsyncLookupReply::ice_staticId() noexcept
{
    return "::IceDiscovery::LookupReply";
}

void
IceDiscovery::AsyncLookup::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
{
    static constexpr std::array<std::string_view, 6> allOperations{"findAdapterById", "findObjectById", "ice_id", "ice_ids", "ice_isA", "ice_ping"};

    const Ice::Current& current = request.current();
    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
    if (r.first == r.second)
    {
        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
        return;
    }

    switch (r.first - allOperations.begin())
    {
        case 0:
        {
            _iceD_findAdapterById(request, std::move(sendResponse));
            break;
        }
        case 1:
        {
            _iceD_findObjectById(request, std::move(sendResponse));
            break;
        }
        case 2:
        {
            _iceD_ice_id(request, std::move(sendResponse));
            break;
        }
        case 3:
        {
            _iceD_ice_ids(request, std::move(sendResponse));
            break;
        }
        case 4:
        {
            _iceD_ice_isA(request, std::move(sendResponse));
            break;
        }
        case 5:
        {
            _iceD_ice_ping(request, std::move(sendResponse));
            break;
        }
        default:
        {
            assert(false);
            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
        }
    }
}

std::vector<std::string>
IceDiscovery::AsyncLookup::ice_ids(const Ice::Current&) const
{
    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::IceDiscovery::Lookup"};
    return allTypeIds;
}

std::string
IceDiscovery::AsyncLookup::ice_id(const Ice::Current&) const
{
    return std::string{ice_staticId()};
}

void
IceDiscovery::AsyncLookup::_iceD_findObjectById(
    Ice::IncomingRequest& request,
    std::function<void(Ice::OutgoingResponse)> sendResponse)
{
    auto istr = &request.inputStream();
    istr->startEncapsulation();
    std::string iceP_domainId;
    ::Ice::Identity iceP_id;
    std::optional<LookupReplyPrx> iceP_reply;
    istr->readAll(iceP_domainId, iceP_id, iceP_reply);
    istr->endEncapsulation();
    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
    try
    {
        this->findObjectByIdAsync(std::move(iceP_domainId), std::move(iceP_id), std::move(iceP_reply), [responseHandler] { responseHandler->sendEmptyResponse(); }, [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
    }
    catch (...)
    {
        responseHandler->sendException(std::current_exception());
    }
}

void
IceDiscovery::AsyncLookup::_iceD_findAdapterById(
    Ice::IncomingRequest& request,
    std::function<void(Ice::OutgoingResponse)> sendResponse)
{
    auto istr = &request.inputStream();
    istr->startEncapsulation();
    std::string iceP_domainId;
    std::string iceP_id;
    std::optional<LookupReplyPrx> iceP_reply;
    istr->readAll(iceP_domainId, iceP_id, iceP_reply);
    istr->endEncapsulation();
    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
    try
    {
        this->findAdapterByIdAsync(std::move(iceP_domainId), std::move(iceP_id), std::move(iceP_reply), [responseHandler] { responseHandler->sendEmptyResponse(); }, [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
    }
    catch (...)
    {
        responseHandler->sendException(std::current_exception());
    }
}

const char*
IceDiscovery::AsyncLookup::ice_staticId() noexcept
{
    return "::IceDiscovery::Lookup";
}
