zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/IceLocatorDiscovery/PluginI.cpp

@@ -1,248 +1,161 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/IceUtil.h>
-#include <Ice/Ice.h>
-#include <Ice/Network.h> // For getInterfacesForMulticast
-#include <Ice/LoggerUtil.h>
+#include "../Ice/Network.h" // For getInterfacesForMulticast
+#include "../Ice/Timer.h"
+#include "Ice/LoggerUtil.h"
+#include "IceLocatorDiscovery/IceLocatorDiscovery.h"
+#include "IceLocatorDiscovery/Lookup.h"
+#include "Plugin.h"
 
-#include <IceLocatorDiscovery/Plugin.h>
-#include <IceLocatorDiscovery/IceLocatorDiscovery.h>
+#include <algorithm>
+#include <thread>
 
 using namespace std;
 using namespace IceLocatorDiscovery;
 
 namespace
 {
+    const char* const locatorDiscoveryPluginName = "IceLocatorDiscovery";
 
-class LocatorI; // Forward declaration
-
-#ifdef ICE_CPP11_MAPPING
-typedef std::pair<function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)>,
-                  function<void(exception_ptr)>> AMDCallback;
-#else
-typedef Ice::AMD_Object_ice_invokePtr AMDCallback;
-#endif
-
-class Request :
-#ifdef ICE_CPP11_MAPPING
-        public std::enable_shared_from_this<Request>
-#else
-        public virtual IceUtil::Shared
-#endif
-{
-public:
-
-    Request(LocatorI* locator,
-            const string& operation,
-            Ice::OperationMode mode,
-            const pair<const Ice::Byte*, const Ice::Byte*>& inParams,
-            const Ice::Context& ctx,
-            const AMDCallback& amdCB) :
-        _locator(locator),
-        _operation(operation),
-        _mode(mode),
-        _context(ctx),
-        _inParams(inParams.first, inParams.second),
-        _amdCB(amdCB)
-    {
-    }
-
-    void invoke(const Ice::LocatorPrxPtr&);
-    void response(bool, const pair<const Ice::Byte*, const Ice::Byte*>&);
-    void exception(const Ice::Exception&);
-
-protected:
-
-    LocatorI* _locator;
-    const string _operation;
-    const Ice::OperationMode _mode;
-    const Ice::Context _context;
-    const Ice::ByteSeq _inParams;
-    AMDCallback _amdCB;
-#ifdef ICE_CPP11_MAPPING
-    exception_ptr _exception;
-#else
-    IceInternal::UniquePtr<Ice::Exception> _exception;
-#endif
-
-    Ice::LocatorPrxPtr _locatorPrx;
-};
-ICE_DEFINE_PTR(RequestPtr, Request);
-
-class LocatorI : public Ice::BlobjectArrayAsync,
-                 public IceUtil::TimerTask,
-                 private IceUtil::Monitor<IceUtil::Mutex>
-#ifdef ICE_CPP11_MAPPING
-               , public std::enable_shared_from_this<LocatorI>
-#endif
-{
-public:
-
-    LocatorI(const string&, const LookupPrxPtr&, const Ice::PropertiesPtr&, const string&, const Ice::LocatorPrxPtr&);
-    void setLookupReply(const LookupReplyPrxPtr&);
-
-#ifdef ICE_CPP11_MAPPING
-    virtual void ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*>,
-                                 function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)>,
-                                 function<void(exception_ptr)>,
-                                 const Ice::Current&);
-#else
-    virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&, const pair<const Ice::Byte*, const Ice::Byte*>&,
-                                  const Ice::Current&);
-#endif
-
-    void foundLocator(const Ice::LocatorPrxPtr&);
-    void invoke(const Ice::LocatorPrxPtr&, const RequestPtr&);
-
-    vector<Ice::LocatorPrxPtr> getLocators(const string&, const IceUtil::Time&);
-
-    void exception(const Ice::LocalException&);
-
-private:
-
-    virtual void runTimerTask();
-
-    LookupPrxPtr _lookup;
-    vector<pair<LookupPrxPtr, LookupReplyPrxPtr> > _lookups;
-    IceUtil::Time _timeout;
-    int _retryCount;
-    IceUtil::Time _retryDelay;
-    const IceUtil::TimerPtr _timer;
-    const int _traceLevel;
-
-    string _instanceName;
-    bool _warned;
-    Ice::LocatorPrxPtr _locator;
-    map<string, Ice::LocatorPrxPtr> _locators;
-    Ice::LocatorPrxPtr _voidLocator;
-
-    IceUtil::Time _nextRetry;
-    bool _pending;
-    int _pendingRetryCount;
-    size_t _failureCount;
-    bool _warnOnce;
-    vector<RequestPtr> _pendingRequests;
-};
-ICE_DEFINE_PTR(LocatorIPtr, LocatorI);
-
-class LookupReplyI : public LookupReply
-{
-public:
-
-    LookupReplyI(const LocatorIPtr& locator) : _locator(locator)
-    {
-    }
-
-    virtual void foundLocator(ICE_IN(Ice::LocatorPrxPtr), const Ice::Current&);
-
-private:
-
-    const LocatorIPtr _locator;
-};
-
-//
-// The void locator implementation below is used when no locator is found.
-//
-class VoidLocatorI : public Ice::Locator
-{
-public:
-
-#ifdef ICE_CPP11_MAPPING
-    virtual void
-    findObjectByIdAsync(::Ice::Identity,
-                        function<void(const shared_ptr<::Ice::ObjectPrx>&)> response,
-                        function<void(exception_ptr)>,
-                        const Ice::Current&) const
-    {
-        response(nullptr);
-    }
-
-    virtual void
-    findAdapterByIdAsync(string,
-                         function<void(const shared_ptr<::Ice::ObjectPrx>&)> response,
-                         function<void(exception_ptr)>,
-                         const Ice::Current&) const
-    {
-        response(nullptr);
-    }
-#else
-    virtual void
-    findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr& amdCB,
-                         const Ice::Identity&,
-                         const Ice::Current&) const
-    {
-        amdCB->ice_response(0);
-    }
-
-    virtual void
-    findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr& amdCB,
-                          const string&,
-                          const Ice::Current&) const
-    {
-        amdCB->ice_response(0);
-    }
-#endif
-
-    virtual Ice::LocatorRegistryPrxPtr
-    getRegistry(const Ice::Current&) const
-    {
-        return ICE_NULLPTR;
-    }
-};
-
-class PluginI : public Plugin
-{
-public:
-
-    PluginI(const std::string&, const Ice::CommunicatorPtr&);
-
-    virtual void initialize();
-    virtual void destroy();
-    virtual vector<Ice::LocatorPrxPtr> getLocators(const string&, const IceUtil::Time&) const;
-
-private:
-
-    const string _name;
-    const Ice::CommunicatorPtr _communicator;
-    Ice::ObjectAdapterPtr _locatorAdapter;
-    Ice::ObjectAdapterPtr _replyAdapter;
-    LocatorIPtr _locator;
-    Ice::LocatorPrxPtr _locatorPrx;
-    Ice::LocatorPrxPtr _defaultLocator;
-};
-
-#ifndef ICE_CPP11_MAPPING
-
-class CallbackI : public IceUtil::Shared
-{
-public:
-
-    CallbackI(const LocatorIPtr& locator) : _locator(locator)
+    class LocatorI; // Forward declaration
+    class Request : public std::enable_shared_from_this<Request>
     {
-    }
+    public:
+        Request(
+            LocatorI* locator,
+            string operation,
+            Ice::OperationMode mode,
+            pair<const byte*, const byte*> inParams,
+            Ice::Context ctx,
+            function<void(bool, pair<const byte*, const byte*>)> responseCallback,
+            function<void(exception_ptr)> exceptionCallback)
+            : _locator(locator),
+              _operation(std::move(operation)),
+              _mode(mode),
+              _context(std::move(ctx)),
+              _inParams(inParams.first, inParams.second),
+              _responseCallback(std::move(responseCallback)),
+              _exceptionCallback(std::move(exceptionCallback))
+        {
+        }
+
+        void invoke(const Ice::LocatorPrx&);
+        void response(bool, pair<const byte*, const byte*>);
+        void exception(std::exception_ptr);
+
+    protected:
+        LocatorI* _locator;
+        const string _operation;
+        const Ice::OperationMode _mode;
+        const Ice::Context _context;
+        const Ice::ByteSeq _inParams;
+        function<void(bool, pair<const byte*, const byte*>)> _responseCallback;
+        function<void(exception_ptr)> _exceptionCallback;
+        exception_ptr _exception;
+
+        optional<Ice::LocatorPrx> _locatorPrx;
+    };
+    using RequestPtr = std::shared_ptr<Request>;
+
+    class LocatorI final : public Ice::BlobjectArrayAsync,
+                           public IceInternal::TimerTask,
+                           public std::enable_shared_from_this<LocatorI>
+    {
+    public:
+        LocatorI(const LookupPrx&, const Ice::PropertiesPtr&, string, Ice::LocatorPrx);
+        void setLookupReply(const LookupReplyPrx&);
+
+        void ice_invokeAsync(
+            pair<const byte*, const byte*>,
+            function<void(bool, pair<const byte*, const byte*>)>,
+            function<void(exception_ptr)>,
+            const Ice::Current&) final;
+
+        void foundLocator(const Ice::LocatorPrx&);
+        void invoke(const optional<Ice::LocatorPrx>&, const RequestPtr&);
+
+        vector<Ice::LocatorPrx> getLocators(const string&, const chrono::milliseconds&);
+
+        void exception(std::exception_ptr);
+
+    private:
+        void runTimerTask() final;
+
+        LookupPrx _lookup;
+        vector<pair<LookupPrx, LookupReplyPrx>> _lookups;
+        chrono::milliseconds _timeout;
+        int _retryCount;
+        chrono::milliseconds _retryDelay;
+        const IceInternal::TimerPtr _timer;
+        const int _traceLevel;
+
+        string _instanceName;
+        bool _warned{false};
+        optional<Ice::LocatorPrx> _locator;
+        map<string, Ice::LocatorPrx> _locators;
+        Ice::LocatorPrx _voidLocator;
+
+        chrono::steady_clock::time_point _nextRetry;
+        bool _pending{false};
+        int _pendingRetryCount{0};
+        size_t _failureCount{0};
+        bool _warnOnce{true};
+        vector<RequestPtr> _pendingRequests;
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
+    using LocatorIPtr = std::shared_ptr<LocatorI>;
+
+    class LookupReplyI final : public LookupReply
+    {
+    public:
+        LookupReplyI(LocatorIPtr locator) : _locator(std::move(locator)) {}
+
+        void foundLocator(optional<Ice::LocatorPrx>, const Ice::Current&) final;
+
+    private:
+        const LocatorIPtr _locator;
+    };
 
-    void
-    completed(const Ice::AsyncResultPtr& result)
+    //
+    // The void locator implementation below is used when no locator is found.
+    //
+    class VoidLocatorI final : public Ice::Locator
     {
-        try
+    public:
+        [[nodiscard]] std::optional<Ice::ObjectPrx> findObjectById(Ice::Identity, const Ice::Current&) const final
         {
-            result->throwLocalException();
+            return nullopt;
         }
-        catch(const Ice::LocalException& ex)
+
+        [[nodiscard]] std::optional<Ice::ObjectPrx> findAdapterById(string, const Ice::Current&) const final
         {
-            _locator->exception(ex);
+            return nullopt;
         }
-    }
 
-private:
+        [[nodiscard]] std::optional<Ice::LocatorRegistryPrx> getRegistry(const Ice::Current&) const final
+        {
+            return nullopt;
+        }
+    };
 
-    LocatorIPtr _locator;
-};
+    class PluginI final : public Plugin
+    {
+    public:
+        PluginI(Ice::CommunicatorPtr);
 
-#endif
+        void initialize() final;
+        void destroy() final;
+        [[nodiscard]] vector<Ice::LocatorPrx> getLocators(const string&, const chrono::milliseconds&) const final;
 
+    private:
+        const Ice::CommunicatorPtr _communicator;
+        Ice::ObjectAdapterPtr _locatorAdapter;
+        Ice::ObjectAdapterPtr _replyAdapter;
+        LocatorIPtr _locator;
+        optional<Ice::LocatorPrx> _locatorPrx;
+        optional<Ice::LocatorPrx> _defaultLocator;
+    };
 }
 
 //
@@ -251,62 +164,53 @@ private:
 extern "C" ICE_LOCATOR_DISCOVERY_API Ice::Plugin*
 createIceLocatorDiscovery(const Ice::CommunicatorPtr& communicator, const string& name, const Ice::StringSeq&)
 {
-    return new PluginI(name, communicator);
-}
+    string pluginName{locatorDiscoveryPluginName};
 
-namespace Ice
-{
-
-ICE_LOCATOR_DISCOVERY_API void
-registerIceLocatorDiscovery(bool loadOnInitialize)
-{
-    Ice::registerPluginFactory("IceLocatorDiscovery", createIceLocatorDiscovery, loadOnInitialize);
-
-#ifdef ICE_STATIC_LIBS
-    //
-    // Also register the UDP plugin with static builds to ensure the UDP transport is loaded.
-    //
-    registerIceUDP(true);
+    if (name != pluginName)
+    {
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4297) // function assumed not to throw an exception but does
 #endif
-}
+        throw Ice::PluginInitializationException{
+            __FILE__,
+            __LINE__,
+            "the Locator Discovery plug-in must be named '" + pluginName + "'"};
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif
+    }
 
+    return new PluginI(communicator);
 }
 
-//
-// Objective-C function to allow Objective-C programs to register plugin.
-//
-extern "C" ICE_LOCATOR_DISCOVERY_API void
-ICEregisterIceLocatorDiscovery(bool loadOnInitialize)
+Ice::PluginFactory
+IceLocatorDiscovery::locatorDiscoveryPluginFactory()
 {
-    Ice::registerIceLocatorDiscovery(loadOnInitialize);
+    return {locatorDiscoveryPluginName, createIceLocatorDiscovery};
 }
 
-PluginI::PluginI(const string& name, const Ice::CommunicatorPtr& communicator) :
-    _name(name), _communicator(communicator)
-{
-}
+Plugin::~Plugin() = default;
+
+PluginI::PluginI(Ice::CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
 void
 PluginI::initialize()
 {
     Ice::PropertiesPtr properties = _communicator->getProperties();
 
-    bool ipv4 = properties->getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
-    bool preferIPv6 = properties->getPropertyAsInt("Ice.PreferIPv6Address") > 0;
-    string address;
-    if(ipv4 && !preferIPv6)
-    {
-        address = properties->getPropertyWithDefault(_name + ".Address", "239.255.0.1");
-    }
-    else
+    bool ipv4 = properties->getIcePropertyAsInt("Ice.IPv4") > 0;
+    bool preferIPv6 = properties->getIcePropertyAsInt("Ice.PreferIPv6Address") > 0;
+    string address = properties->getIceProperty("IceLocatorDiscovery.Address");
+    if (address.empty())
     {
-        address = properties->getPropertyWithDefault(_name + ".Address", "ff15::1");
+        address = ipv4 && !preferIPv6 ? "239.255.0.1" : "ff15::1";
     }
-    int port = properties->getPropertyAsIntWithDefault(_name + ".Port", 4061);
-    string intf = properties->getProperty(_name + ".Interface");
+    int port = properties->getIcePropertyAsInt("IceLocatorDiscovery.Port");
+    string intf = properties->getIceProperty("IceLocatorDiscovery.Interface");
 
-    string lookupEndpoints = properties->getProperty(_name + ".Lookup");
-    if(lookupEndpoints.empty())
+    string lookupEndpoints = properties->getIceProperty("IceLocatorDiscovery.Lookup");
+    if (lookupEndpoints.empty())
     {
         //
         // If no lookup endpoints are specified, we get all the network interfaces and create
@@ -315,9 +219,9 @@ PluginI::initialize()
         IceInternal::ProtocolSupport protocol = ipv4 && !preferIPv6 ? IceInternal::EnableIPv4 : IceInternal::EnableIPv6;
         vector<string> interfaces = IceInternal::getInterfacesForMulticast(intf, protocol);
         ostringstream lookup;
-        for(vector<string>::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
+        for (auto p = interfaces.begin(); p != interfaces.end(); ++p)
         {
-            if(p != interfaces.begin())
+            if (p != interfaces.begin())
             {
                 lookup << ":";
             }
@@ -326,49 +230,48 @@ PluginI::initialize()
         lookupEndpoints = lookup.str();
     }
 
-    if(properties->getProperty(_name + ".Reply.Endpoints").empty())
+    if (properties->getIceProperty("IceLocatorDiscovery.Reply.Endpoints").empty())
     {
-        properties->setProperty(_name + ".Reply.Endpoints", "udp -h " + (intf.empty() ? "*" : "\"" + intf + "\""));
+        properties->setProperty(
+            "IceLocatorDiscovery.Reply.Endpoints",
+            "udp -h " + (intf.empty() ? "*" : "\"" + intf + "\""));
     }
 
-    if(properties->getProperty(_name + ".Locator.Endpoints").empty())
+    if (properties->getIceProperty("IceLocatorDiscovery.Locator.Endpoints").empty())
     {
-        properties->setProperty(_name + ".Locator.AdapterId", Ice::generateUUID()); // Collocated adapter
+        properties->setProperty("IceLocatorDiscovery.Locator.AdapterId", Ice::generateUUID()); // Collocated adapter
     }
 
-    _replyAdapter = _communicator->createObjectAdapter(_name + ".Reply");
-    _locatorAdapter = _communicator->createObjectAdapter(_name + ".Locator");
+    _replyAdapter = _communicator->createObjectAdapter("IceLocatorDiscovery.Reply");
+    _locatorAdapter = _communicator->createObjectAdapter("IceLocatorDiscovery.Locator");
 
     // We don't want those adapters to be registered with the locator so clear their locator.
-    _replyAdapter->setLocator(0);
-    _locatorAdapter->setLocator(0);
+    _replyAdapter->setLocator(nullopt);
+    _locatorAdapter->setLocator(nullopt);
 
-    Ice::ObjectPrxPtr lookupPrx = _communicator->stringToProxy("IceLocatorDiscovery/Lookup -d:" + lookupEndpoints);
-    // No collocation optimization for the multicast proxy!
-    lookupPrx = lookupPrx->ice_collocationOptimized(false)->ice_router(ICE_NULLPTR);
+    LookupPrx lookupPrx(_communicator, "IceLocatorDiscovery/Lookup -d:" + lookupEndpoints);
+    lookupPrx = lookupPrx->ice_router(nullopt);
 
-    Ice::LocatorPrxPtr voidLocator = ICE_UNCHECKED_CAST(Ice::LocatorPrx,
-                                                        _locatorAdapter->addWithUUID(ICE_MAKE_SHARED(VoidLocatorI)));
+    auto voidLocator = _locatorAdapter->addWithUUID<Ice::LocatorPrx>(make_shared<VoidLocatorI>());
 
-    string instanceName = properties->getProperty(_name + ".InstanceName");
+    string instanceName = properties->getIceProperty("IceLocatorDiscovery.InstanceName");
     Ice::Identity id;
     id.name = "Locator";
     id.category = !instanceName.empty() ? instanceName : Ice::generateUUID();
-    _locator = ICE_MAKE_SHARED(LocatorI, _name, ICE_UNCHECKED_CAST(LookupPrx, lookupPrx), properties, instanceName,
-                               voidLocator);
+    _locator = make_shared<LocatorI>(lookupPrx, properties, instanceName, voidLocator);
     _defaultLocator = _communicator->getDefaultLocator();
-    _locatorPrx = ICE_UNCHECKED_CAST(Ice::LocatorPrx, _locatorAdapter->add(_locator, id));
+    _locatorPrx = _locatorAdapter->add<Ice::LocatorPrx>(_locator, id);
     _communicator->setDefaultLocator(_locatorPrx);
 
-    Ice::ObjectPrxPtr lookupReply = _replyAdapter->addWithUUID(ICE_MAKE_SHARED(LookupReplyI, _locator))->ice_datagram();
-    _locator->setLookupReply(ICE_UNCHECKED_CAST(LookupReplyPrx, lookupReply));
+    auto lookupReply = _replyAdapter->addWithUUID<LookupReplyPrx>(make_shared<LookupReplyI>(_locator))->ice_datagram();
+    _locator->setLookupReply(lookupReply);
 
     _replyAdapter->activate();
     _locatorAdapter->activate();
 }
 
-vector<Ice::LocatorPrxPtr>
-PluginI::getLocators(const string& instanceName, const IceUtil::Time& waitTime) const
+vector<Ice::LocatorPrx>
+PluginI::getLocators(const string& instanceName, const chrono::milliseconds& waitTime) const
 {
     return _locator->getLocators(instanceName, waitTime);
 }
@@ -376,15 +279,15 @@ PluginI::getLocators(const string& instanceName, const IceUtil::Time& waitTime)
 void
 PluginI::destroy()
 {
-    if(_replyAdapter)
+    if (_replyAdapter)
     {
         _replyAdapter->destroy();
     }
-    if(_locatorAdapter)
+    if (_locatorAdapter)
     {
         _locatorAdapter->destroy();
     }
-    if(_communicator->getDefaultLocator() == _locatorPrx)
+    if (_communicator->getDefaultLocator() == _locatorPrx)
     {
         // Restore original default locator proxy, if the user didn't change it in the meantime
         _communicator->setDefaultLocator(_defaultLocator);
@@ -392,334 +295,223 @@ PluginI::destroy()
 }
 
 void
-Request::invoke(const Ice::LocatorPrxPtr& l)
+Request::invoke(const Ice::LocatorPrx& l)
 {
-#ifdef ICE_CPP11_MAPPING
-    if(l != _locatorPrx)
+    if (l != _locatorPrx)
     {
         _locatorPrx = l;
         try
         {
             auto self = shared_from_this();
-            l->ice_invokeAsync(_operation, _mode, _inParams,
-                               [self](bool ok, vector<Ice::Byte> outParams)
-                               {
-                                   pair<const Ice::Byte*, const Ice::Byte*> outPair;
-                                   if(outParams.empty())
-                                   {
-                                       outPair.first = outPair.second = 0;
-                                   }
-                                   else
-                                   {
-                                       outPair.first = &outParams[0];
-                                       outPair.second = outPair.first + outParams.size();
-                                   }
-                                   self->response(ok, outPair);
-                               },
-                               [self](exception_ptr e)
-                               {
-                                   try
-                                   {
-                                       rethrow_exception(e);
-                                   }
-                                   catch(const Ice::Exception& ex)
-                                   {
-                                       self->exception(ex);
-                                   }
-                               },
-                               nullptr,
-                               _context);
+            l->ice_invokeAsync(
+                _operation,
+                _mode,
+                _inParams,
+                [self](bool ok, vector<byte> outParams)
+                {
+                    pair<const byte*, const byte*> outPair;
+                    if (outParams.empty())
+                    {
+                        outPair.first = outPair.second = 0;
+                    }
+                    else
+                    {
+                        outPair.first = &outParams[0];
+                        outPair.second = outPair.first + outParams.size();
+                    }
+                    self->response(ok, outPair);
+                },
+                [self](exception_ptr e) { self->exception(e); },
+                nullptr,
+                _context);
         }
-        catch(const Ice::LocalException& ex)
+        catch (const Ice::LocalException&)
         {
-            exception(ex);
+            exception(current_exception());
         }
     }
     else
     {
         assert(_exception); // Don't retry if the proxy didn't change
-        _amdCB.second(_exception);
-    }
-
-#else
-    if(l != _locatorPrx)
-    {
-        _locatorPrx = l;
-        try
-        {
-            l->begin_ice_invoke(_operation, _mode, _inParams, _context,
-                                Ice::newCallback_Object_ice_invoke(this, &Request::response, &Request::exception));
-        }
-        catch(const Ice::LocalException& ex)
-        {
-            exception(ex);
-        }
-    }
-    else
-    {
-        assert(_exception.get()); // Don't retry if the proxy didn't change
-        _amdCB->ice_exception(*_exception.get());
+        _exceptionCallback(_exception);
     }
-#endif
 }
 
 void
-Request::response(bool ok, const pair<const Ice::Byte*, const Ice::Byte*>& outParams)
+Request::response(bool ok, pair<const byte*, const byte*> outParams)
 {
-#ifdef ICE_CPP11_MAPPING
-    _amdCB.first(ok, outParams);
-#else
-    _amdCB->ice_response(ok, outParams);
-#endif
+    _responseCallback(ok, outParams);
 }
 
 void
-Request::exception(const Ice::Exception& ex)
+Request::exception(std::exception_ptr ex)
 {
-#ifdef ICE_CPP11_MAPPING
     try
     {
-        ex.ice_throw();
+        rethrow_exception(ex);
     }
-    catch(const Ice::RequestFailedException&)
+    catch (const Ice::RequestFailedException&)
     {
-        _amdCB.second(current_exception());
+        _exceptionCallback(ex);
     }
-    catch(const Ice::UnknownException&)
+    catch (const Ice::UnknownException&)
     {
-        _amdCB.second(current_exception());
+        _exceptionCallback(ex);
     }
-    catch(const Ice::NoEndpointException&)
+    catch (const Ice::NoEndpointException&)
     {
-        try
-        {
-            throw Ice::ObjectNotExistException(__FILE__, __LINE__);
-        }
-        catch(...)
-        {
-            _amdCB.second(current_exception());
-        }
+        _exceptionCallback(make_exception_ptr(Ice::ObjectNotExistException{__FILE__, __LINE__}));
     }
-    catch(const Ice::CommunicatorDestroyedException&)
+    catch (const Ice::CommunicatorDestroyedException&)
     {
-        try
-        {
-            throw Ice::ObjectNotExistException(__FILE__, __LINE__);
-        }
-        catch(...)
-        {
-            _amdCB.second(current_exception());
-        }
+        _exceptionCallback(make_exception_ptr(Ice::ObjectNotExistException{__FILE__, __LINE__}));
     }
-    catch(const Ice::ObjectAdapterDeactivatedException&)
+    catch (const Ice::ObjectAdapterDeactivatedException&)
     {
-        try
-        {
-            throw Ice::ObjectNotExistException(__FILE__, __LINE__);
-        }
-        catch(...)
-        {
-            _amdCB.second(current_exception());
-        }
-    }
-    catch(const Ice::Exception&)
-    {
-        _exception = current_exception();
-        _locator->invoke(_locatorPrx, shared_from_this()); // Retry with new locator proxy
-    }
-#else
-    try
-    {
-        ex.ice_throw();
-    }
-    catch(const Ice::RequestFailedException&)
-    {
-        _amdCB->ice_exception(ex);
-    }
-    catch(const Ice::UnknownException&)
-    {
-        _amdCB->ice_exception(ex);
-    }
-    catch(const Ice::NoEndpointException&)
-    {
-        _amdCB->ice_exception(Ice::ObjectNotExistException(__FILE__, __LINE__));
+        _exceptionCallback(make_exception_ptr(Ice::ObjectNotExistException{__FILE__, __LINE__}));
     }
-    catch(const Ice::CommunicatorDestroyedException&)
+    catch (const Ice::ObjectAdapterDestroyedException&)
     {
-        _amdCB->ice_exception(Ice::ObjectNotExistException(__FILE__, __LINE__));
+        _exceptionCallback(make_exception_ptr(Ice::ObjectNotExistException{__FILE__, __LINE__}));
     }
-    catch(const Ice::ObjectAdapterDeactivatedException&)
+    catch (...)
     {
-        _amdCB->ice_exception(Ice::ObjectNotExistException(__FILE__, __LINE__));
-    }
-    catch(const Ice::Exception&)
-    {
-        _exception.reset(ex.ice_clone());
-        _locator->invoke(_locatorPrx, this); // Retry with new locator proxy
+        _exception = ex;
+        _locator->invoke(_locatorPrx, shared_from_this()); // Retry with new locator proxy
     }
-#endif
 }
 
-LocatorI::LocatorI(const string& name,
-                   const LookupPrxPtr& lookup,
-                   const Ice::PropertiesPtr& p,
-                   const string& instanceName,
-                   const Ice::LocatorPrxPtr& voidLocator) :
-    _lookup(lookup),
-    _timeout(IceUtil::Time::milliSeconds(p->getPropertyAsIntWithDefault(name + ".Timeout", 300))),
-    _retryCount(p->getPropertyAsIntWithDefault(name + ".RetryCount", 3)),
-    _retryDelay(IceUtil::Time::milliSeconds(p->getPropertyAsIntWithDefault(name + ".RetryDelay", 2000))),
-    _timer(IceInternal::getInstanceTimer(lookup->ice_getCommunicator())),
-    _traceLevel(p->getPropertyAsInt(name + ".Trace.Lookup")),
-    _instanceName(instanceName),
-    _warned(false),
-    _locator(lookup->ice_getCommunicator()->getDefaultLocator()),
-    _voidLocator(voidLocator),
-    _pending(false),
-    _pendingRetryCount(0),
-    _failureCount(0),
-    _warnOnce(true)
+LocatorI::LocatorI(
+    const LookupPrx& lookup,
+    const Ice::PropertiesPtr& p,
+    string instanceName,
+    Ice::LocatorPrx voidLocator)
+    : _lookup(lookup),
+      _timeout(chrono::milliseconds(p->getIcePropertyAsInt("IceLocatorDiscovery.Timeout"))),
+      _retryCount(p->getIcePropertyAsInt("IceLocatorDiscovery.RetryCount")),
+      _retryDelay(chrono::milliseconds(p->getIcePropertyAsInt("IceLocatorDiscovery.RetryDelay"))),
+      _timer(IceInternal::getInstanceTimer(lookup->ice_getCommunicator())),
+      _traceLevel(p->getIcePropertyAsInt("IceLocatorDiscovery.Trace.Lookup")),
+      _instanceName(std::move(instanceName)),
+      _locator(lookup->ice_getCommunicator()->getDefaultLocator()),
+      _voidLocator(std::move(voidLocator))
 {
-    if(_timeout < IceUtil::Time::milliSeconds(0))
+    if (_timeout < chrono::milliseconds::zero())
     {
-        _timeout = IceUtil::Time::milliSeconds(300);
+        _timeout = chrono::milliseconds(300);
     }
-    if(_retryCount < 0)
+    if (_retryCount < 0)
     {
         _retryCount = 0;
     }
-    if(_retryDelay < IceUtil::Time::milliSeconds(0))
-    {
-        _retryDelay = IceUtil::Time::milliSeconds(0);
-    }
-
-    //
-    // Create one lookup proxy per endpoint from the given proxy. We want to send a multicast
-    // datagram on each endpoint.
-    //
-    Ice::EndpointSeq endpoints = lookup->ice_getEndpoints();
-    for(vector<Ice::EndpointPtr>::const_iterator q = endpoints.begin(); q != endpoints.end(); ++q)
+    if (_retryDelay < chrono::milliseconds::zero())
     {
-        Ice::EndpointSeq single;
-        single.push_back(*q);
-        _lookups.push_back(make_pair(lookup->ice_endpoints(single), LookupReplyPrxPtr()));
+        _retryDelay = chrono::milliseconds::zero();
     }
-    assert(!_lookups.empty());
 }
 
 void
-LocatorI::setLookupReply(const LookupReplyPrxPtr& lookupReply)
+LocatorI::setLookupReply(const LookupReplyPrx& lookupReply)
 {
-    //
-    // Use a lookup reply proxy whose adress matches the interface used to send multicast datagrams.
-    //
-    for(vector<pair<LookupPrxPtr, LookupReplyPrxPtr> >::iterator p = _lookups.begin(); p != _lookups.end(); ++p)
+    // Create one lookup proxy per endpoint from the given proxy. We want to send a multicast datagram on each
+    // endpoint.
+    for (const auto& lookupEndpoint : _lookup->ice_getEndpoints())
     {
-        Ice::UDPEndpointInfoPtr info = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, p->first->ice_getEndpoints()[0]->getInfo());
-        if(info && !info->mcastInterface.empty())
+        LookupReplyPrx reply = lookupReply;
+        auto info = dynamic_pointer_cast<Ice::UDPEndpointInfo>(lookupEndpoint->getInfo());
+        // Use a lookup reply proxy whose address matches the interface used to send multicast datagrams.
+        if (info && !info->mcastInterface.empty())
         {
-            Ice::EndpointSeq endpts = lookupReply->ice_getEndpoints();
-            for(Ice::EndpointSeq::const_iterator q = endpts.begin(); q != endpts.end(); ++q)
+            for (const auto& replyEndpoint : reply->ice_getEndpoints())
             {
-                Ice::IPEndpointInfoPtr r = ICE_DYNAMIC_CAST(Ice::IPEndpointInfo, (*q)->getInfo());
-                if(r && r->host == info->mcastInterface)
+                Ice::IPEndpointInfoPtr r = dynamic_pointer_cast<Ice::IPEndpointInfo>(replyEndpoint->getInfo());
+                if (r && r->host == info->mcastInterface)
                 {
-                    Ice::EndpointSeq single;
-                    single.push_back(*q);
-                    p->second = lookupReply->ice_endpoints(single);
+                    reply = reply->ice_endpoints(Ice::EndpointSeq{replyEndpoint});
+                    break;
                 }
             }
         }
 
-        if(!p->second)
-        {
-            p->second = lookupReply; // Fallback: just use the given lookup reply proxy if no matching endpoint found.
-        }
+        _lookups.emplace_back(_lookup->ice_endpoints(Ice::EndpointSeq{lookupEndpoint}), reply);
     }
+    assert(!_lookups.empty());
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
-LocatorI::ice_invokeAsync(pair<const Ice::Byte*, const Ice::Byte*> inParams,
-                          function<void(bool, const pair<const Ice::Byte*, const Ice::Byte*>&)> responseCB,
-                          function<void(exception_ptr)> exceptionCB,
-                          const Ice::Current& current)
+LocatorI::ice_invokeAsync(
+    pair<const byte*, const byte*> inParams,
+    function<void(bool, pair<const byte*, const byte*>)> responseCB,
+    function<void(exception_ptr)> exceptionCB,
+    const Ice::Current& current)
 {
-    invoke(nullptr, make_shared<Request>(this, current.operation, current.mode, inParams, current.ctx,
-                                         make_pair(std::move(responseCB), std::move(exceptionCB))));
+    invoke(
+        nullopt,
+        make_shared<Request>(
+            this,
+            current.operation,
+            current.mode,
+            inParams,
+            current.ctx,
+            std::move(responseCB),
+            std::move(exceptionCB)));
 }
-#else
-void
-LocatorI::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& amdCB,
-                           const pair<const Ice::Byte*, const Ice::Byte*>& inParams,
-                           const Ice::Current& current)
-{
-    invoke(0, new Request(this, current.operation, current.mode, inParams, current.ctx, amdCB));
-}
-#endif
 
-vector<Ice::LocatorPrxPtr>
-LocatorI::getLocators(const string& instanceName, const IceUtil::Time& waitTime)
+vector<Ice::LocatorPrx>
+LocatorI::getLocators(const string& instanceName, const chrono::milliseconds& waitTime)
 {
     //
     // Clear locators from previous search
     //
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
         _locators.clear();
     }
 
     //
     // Find a locator
     //
-    invoke(ICE_NULLPTR, ICE_NULLPTR);
+    invoke(nullopt, nullptr);
 
     //
     // Wait for responses
     //
-    if(instanceName.empty())
+    if (instanceName.empty())
     {
-        IceUtil::ThreadControl::sleep(waitTime);
+        std::this_thread::sleep_for(waitTime);
     }
     else
     {
-        Lock sync(*this);
-        while(_locators.find(instanceName) == _locators.end() && _pending)
+        unique_lock lock(_mutex);
+        while (_locators.find(instanceName) == _locators.end() && _pending)
         {
-            timedWait(waitTime);
+            if (_conditionVariable.wait_for(lock, waitTime) == cv_status::timeout)
+            {
+                break;
+            }
         }
     }
 
     //
     // Return found locators
     //
-    Lock sync(*this);
-    vector<Ice::LocatorPrxPtr> locators;
-    for(map<string, Ice::LocatorPrxPtr>::const_iterator p = _locators.begin(); p != _locators.end(); ++p)
+    lock_guard lock(_mutex);
+    vector<Ice::LocatorPrx> locators;
+    locators.reserve(_locators.size());
+    for (const auto& [_, locator] : _locators)
     {
-        locators.push_back(p->second);
+        locators.push_back(locator);
     }
     return locators;
 }
 
 void
-LocatorI::foundLocator(const Ice::LocatorPrxPtr& locator)
+LocatorI::foundLocator(const Ice::LocatorPrx& locator)
 {
-    Lock sync(*this);
-
-    if(!locator)
-    {
-        if(_traceLevel > 2)
-        {
-            Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
-            out << "ignoring locator reply: (null locator)";
-        }
-        return;
-    }
-
-    if(!_instanceName.empty() && locator->ice_getIdentity().category != _instanceName)
+    lock_guard lock(_mutex);
+    if (!_instanceName.empty() && locator->ice_getIdentity().category != _instanceName)
     {
-        if(_traceLevel > 2)
+        if (_traceLevel > 2)
         {
             Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
             out << "ignoring locator reply: instance name doesn't match\n";
@@ -729,21 +521,18 @@ LocatorI::foundLocator(const Ice::LocatorPrxPtr& locator)
         return;
     }
 
-    //
-    // If we already have a locator assigned, ensure the given locator
-    // has the same identity, otherwise ignore it.
-    //
-    if(!_pendingRequests.empty() &&
-       _locator && locator->ice_getIdentity().category != _locator->ice_getIdentity().category)
+    // If we already have a locator assigned, ensure the given locator has the same identity, otherwise ignore it.
+    if (!_pendingRequests.empty() && _locator &&
+        locator->ice_getIdentity().category != _locator->ice_getIdentity().category)
     {
-        if(!_warned)
+        if (!_warned)
         {
             _warned = true; // Only warn once.
 
             Ice::Warning out(locator->ice_getCommunicator()->getLogger());
             out << "received Ice locator with different instance name:\n";
-            out << "using = `" << _locator->ice_getIdentity().category << "'\n";
-            out << "received = `" << locator->ice_getIdentity().category << "'\n";
+            out << "using = '" << _locator->ice_getIdentity().category << "'\n";
+            out << "received = '" << locator->ice_getIdentity().category << "'\n";
             out << "This is typically the case if multiple Ice locators with different";
             out << "instance names are deployed and the property `IceLocatorDiscovery.InstanceName' ";
             out << "is not set.";
@@ -751,158 +540,128 @@ LocatorI::foundLocator(const Ice::LocatorPrxPtr& locator)
         return;
     }
 
-    if(_pending) // No need to continue, we found a locator.
+    if (_pending) // No need to continue, we found a locator.
     {
-        _timer->cancel(ICE_SHARED_FROM_THIS);
+        _timer->cancel(shared_from_this());
         _pendingRetryCount = 0;
         _pending = false;
     }
 
-    if(_traceLevel > 0)
+    if (_traceLevel > 0)
     {
         Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
         out << "locator lookup succeeded:\nlocator = " << locator;
-        if(!_instanceName.empty())
+        if (!_instanceName.empty())
         {
             out << "\ninstance name = " << _instanceName;
         }
     }
 
-    Ice::LocatorPrxPtr l = _pendingRequests.empty() ? _locators[locator->ice_getIdentity().category] : _locator;
-    if(l)
+    auto i = _locators.find(locator->ice_getIdentity().category);
+    if (i != _locators.end())
     {
-        //
-        // We found another locator replica, append its endpoints to the
-        // current locator proxy endpoints.
-        //
-        Ice::EndpointSeq newEndpoints = l->ice_getEndpoints();
-        Ice::EndpointSeq endpts = locator->ice_getEndpoints();
-        for(Ice::EndpointSeq::const_iterator p = endpts.begin(); p != endpts.end(); ++p)
+        // We found another locator replica, append its endpoints to the current locator proxy endpoints.
+        Ice::EndpointSeq newEndpoints = i->second->ice_getEndpoints();
+        for (const auto& endpoint : locator->ice_getEndpoints())
         {
-            //
-            // Only add endpoints if not already in the locator proxy endpoints
-            //
-            bool found = false;
-            for(Ice::EndpointSeq::const_iterator q = newEndpoints.begin(); q != newEndpoints.end(); ++q)
+            if (std::find(newEndpoints.begin(), newEndpoints.end(), endpoint) == newEndpoints.end())
             {
-                if(*p == *q)
-                {
-                    found = true;
-                    break;
-                }
-            }
-            if(!found)
-            {
-                newEndpoints.push_back(*p);
+                newEndpoints.push_back(endpoint);
             }
         }
-        l = l->ice_endpoints(newEndpoints);
+        i->second = i->second->ice_endpoints(newEndpoints);
     }
     else
     {
-        l = locator;
+        _locators.insert(make_pair(locator->ice_getIdentity().category, locator));
     }
 
-    if(_pendingRequests.empty())
+    Ice::LocatorPrx l = i == _locators.end() ? locator : i->second;
+
+    if (_pendingRequests.empty())
     {
-        _locators[locator->ice_getIdentity().category] = l;
-        notify();
+        _conditionVariable.notify_one();
     }
     else
     {
         _locator = l;
-        if(_instanceName.empty())
+        if (_instanceName.empty())
         {
             _instanceName = _locator->ice_getIdentity().category; // Stick to the first discovered locator.
         }
 
-        //
         // Send pending requests if any.
-        //
-        for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
+        for (const auto& pendingRequest : _pendingRequests)
         {
-            (*p)->invoke(_locator);
+            pendingRequest->invoke(l);
         }
         _pendingRequests.clear();
     }
 }
 
 void
-LocatorI::invoke(const Ice::LocatorPrxPtr& locator, const RequestPtr& request)
+LocatorI::invoke(const optional<Ice::LocatorPrx>& locator, const RequestPtr& request)
 {
-    Lock sync(*this);
-    if(request && _locator && _locator != locator)
+    lock_guard lock(_mutex);
+    if (request && _locator && _locator != locator)
     {
-        request->invoke(_locator);
+        request->invoke(*_locator);
     }
-    else if(request && IceUtil::Time::now() < _nextRetry)
+    else if (request && chrono::steady_clock::now() < _nextRetry)
     {
         request->invoke(_voidLocator); // Don't retry to find a locator before the retry delay expires
     }
     else
     {
-        _locator = 0;
+        _locator = nullopt;
 
-        if(request)
+        if (request)
         {
             _pendingRequests.push_back(request);
         }
 
-        if(!_pending) // No request in progress
+        if (!_pending) // No request in progress
         {
             _pending = true;
             _failureCount = 0;
             _pendingRetryCount = _retryCount;
             try
             {
-                if(_traceLevel > 1)
+                if (_traceLevel > 1)
                 {
                     Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
                     out << "looking up locator:\nlookup = " << _lookup;
-                    if(!_instanceName.empty())
+                    if (!_instanceName.empty())
                     {
                         out << "\ninstance name = " << _instanceName;
                     }
                 }
-                for(vector<pair<LookupPrxPtr, LookupReplyPrxPtr> >::const_iterator l = _lookups.begin();
-                    l != _lookups.end(); ++l)
+                for (const auto& l : _lookups)
                 {
-#ifdef ICE_CPP11_MAPPING
-                    auto self = shared_from_this();
-                    l->first->findLocatorAsync(_instanceName, l->second, nullptr, [self](exception_ptr ex)
-                    {
-                        try
-                        {
-                            rethrow_exception(ex);
-                        }
-                        catch(const Ice::LocalException& e)
-                        {
-                            self->exception(e);
-                        }
-                    });
-#else
-                    l->first->begin_findLocator(_instanceName, l->second, Ice::newCallback(new CallbackI(this),
-                                                                                           &CallbackI::completed));
-#endif
+                    l.first->findLocatorAsync(
+                        _instanceName,
+                        l.second,
+                        nullptr,
+                        [self = shared_from_this()](exception_ptr ex) { self->exception(ex); });
                 }
-                _timer->schedule(ICE_SHARED_FROM_THIS, _timeout);
+                _timer->schedule(shared_from_this(), _timeout);
             }
-            catch(const Ice::LocalException& ex)
+            catch (const Ice::LocalException& ex)
             {
-                if(_traceLevel > 0)
+                if (_traceLevel > 0)
                 {
                     Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
                     out << "locator lookup failed:\nlookup = " << _lookup;
-                    if(!_instanceName.empty())
+                    if (!_instanceName.empty())
                     {
                         out << "\ninstance name = " << _instanceName;
                     }
                     out << "\n" << ex;
                 }
 
-                for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
+                for (const auto& pendingRequest : _pendingRequests)
                 {
-                    (*p)->invoke(_voidLocator);
+                    pendingRequest->invoke(_voidLocator);
                 }
                 _pendingRequests.clear();
                 _pending = false;
@@ -913,47 +672,62 @@ LocatorI::invoke(const Ice::LocatorPrxPtr& locator, const RequestPtr& request)
 }
 
 void
-LocatorI::exception(const Ice::LocalException& ex)
+LocatorI::exception(std::exception_ptr ex)
 {
-    Lock sync(*this);
-    if(++_failureCount == _lookups.size() && _pending)
+    lock_guard lock(_mutex);
+    if (++_failureCount == _lookups.size() && _pending)
     {
         //
         // All the lookup calls failed, cancel the timer and propagate the error to the requests.
         //
-        _timer->cancel(ICE_SHARED_FROM_THIS);
+        _timer->cancel(shared_from_this());
         _pendingRetryCount = 0;
         _pending = false;
 
-        if(_warnOnce)
+        if (_warnOnce)
         {
-            Ice::Warning warn(_lookup->ice_getCommunicator()->getLogger());
-            warn << "failed to lookup locator with lookup proxy `" << _lookup << "':\n" << ex;
-            _warnOnce = false;
+            try
+            {
+                rethrow_exception(ex);
+            }
+            catch (const std::exception& e)
+            {
+                Ice::Warning warn(_lookup->ice_getCommunicator()->getLogger());
+                warn << "failed to lookup locator with lookup proxy '" << _lookup << "':\n" << e;
+                _warnOnce = false;
+            }
         }
 
-        if(_traceLevel > 0)
+        if (_traceLevel > 0)
         {
             Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
             out << "locator lookup failed:\nlookup = " << _lookup;
-            if(!_instanceName.empty())
+            if (!_instanceName.empty())
             {
                 out << "\ninstance name = " << _instanceName;
             }
-            out << "\n" << ex;
+
+            try
+            {
+                rethrow_exception(ex);
+            }
+            catch (const std::exception& e)
+            {
+                out << "\n" << e;
+            }
         }
 
-        if(_pendingRequests.empty())
+        if (_pendingRequests.empty())
         {
-            notify();
+            _conditionVariable.notify_one();
         }
         else
         {
-            for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
+            for (const auto& pendingRequest : _pendingRequests)
             {
-                (*p)->invoke(_voidLocator);
+                pendingRequest->invoke(_voidLocator);
             }
-           _pendingRequests.clear();
+            _pendingRequests.clear();
         }
     }
 }
@@ -961,53 +735,40 @@ LocatorI::exception(const Ice::LocalException& ex)
 void
 LocatorI::runTimerTask()
 {
-    Lock sync(*this);
-    if(!_pending)
+    lock_guard lock(_mutex);
+    if (!_pending)
     {
         assert(_pendingRequests.empty());
         return; // The request failed
     }
 
-    if(_pendingRetryCount > 0)
+    if (_pendingRetryCount > 0)
     {
         --_pendingRetryCount;
         try
         {
-            if(_traceLevel > 1)
+            if (_traceLevel > 1)
             {
                 Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
                 out << "retrying locator lookup:\nlookup = " << _lookup << "\nretry count = " << _pendingRetryCount;
-                if(!_instanceName.empty())
+                if (!_instanceName.empty())
                 {
                     out << "\ninstance name = " << _instanceName;
                 }
             }
             _failureCount = 0;
-            for(vector<pair<LookupPrxPtr, LookupReplyPrxPtr> >::const_iterator l = _lookups.begin();
-                l != _lookups.end(); ++l)
+            for (const auto& l : _lookups)
             {
-#ifdef ICE_CPP11_MAPPING
-                    auto self = shared_from_this();
-                    l->first->findLocatorAsync(_instanceName, l->second, nullptr, [self](exception_ptr ex)
-                    {
-                        try
-                        {
-                            rethrow_exception(ex);
-                        }
-                        catch(const Ice::LocalException& e)
-                        {
-                            self->exception(e);
-                        }
-                    });
-#else
-                    l->first->begin_findLocator(_instanceName, l->second, Ice::newCallback(new CallbackI(this),
-                                                                                           &CallbackI::completed));
-#endif
+                l.first->findLocatorAsync(
+                    _instanceName,
+                    l.second,
+                    nullptr,
+                    [self = shared_from_this()](exception_ptr ex) { self->exception(ex); });
             }
-            _timer->schedule(ICE_SHARED_FROM_THIS, _timeout);
+            _timer->schedule(shared_from_this(), _timeout);
             return;
         }
-        catch(const Ice::LocalException&)
+        catch (const Ice::LocalException&)
         {
         }
         _pendingRetryCount = 0;
@@ -1016,33 +777,34 @@ LocatorI::runTimerTask()
     assert(_pendingRetryCount == 0);
     _pending = false;
 
-    if(_traceLevel > 0)
+    if (_traceLevel > 0)
     {
         Ice::Trace out(_lookup->ice_getCommunicator()->getLogger(), "Lookup");
         out << "locator lookup timed out:\nlookup = " << _lookup;
-        if(!_instanceName.empty())
+        if (!_instanceName.empty())
         {
             out << "\ninstance name = " << _instanceName;
         }
     }
 
-    if(_pendingRequests.empty())
+    if (_pendingRequests.empty())
     {
-        notify();
+        _conditionVariable.notify_one();
     }
     else
     {
-        for(vector<RequestPtr>::const_iterator p = _pendingRequests.begin(); p != _pendingRequests.end(); ++p)
+        for (const auto& pendingRequest : _pendingRequests)
         {
-            (*p)->invoke(_voidLocator); // Send pending requests on void locator.
+            pendingRequest->invoke(_voidLocator); // Send pending requests on void locator.
         }
-       _pendingRequests.clear();
+        _pendingRequests.clear();
     }
-    _nextRetry = IceUtil::Time::now() + _retryDelay; // Only retry when the retry delay expires
+    _nextRetry = chrono::steady_clock::now() + _retryDelay; // Only retry when the retry delay expires
 }
 
 void
-LookupReplyI::foundLocator(ICE_IN(Ice::LocatorPrxPtr) locator, const Ice::Current&)
+LookupReplyI::foundLocator(optional<Ice::LocatorPrx> locator, const Ice::Current& current)
 {
-    _locator->foundLocator(locator);
+    checkNotNull(locator, __FILE__, __LINE__, current);
+    _locator->foundLocator(*locator);
 }