zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/LocatorInfo.cpp

@@ -1,143 +1,94 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <IceUtil/DisableWarnings.h>
-#include <Ice/LocatorInfo.h>
-#include <Ice/Locator.h>
-#include <Ice/LocalException.h>
-#include <Ice/Instance.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/EndpointI.h>
-#include <Ice/Reference.h>
-#include <Ice/Functional.h>
-#include <Ice/Properties.h>
-#include <Ice/Comparable.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "LocatorInfo.h"
+#include "EndpointI.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Locator.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Properties.h"
+#include "Ice/ProxyFunctions.h"
+#include "Instance.h"
+#include "Reference.h"
+#include "TraceLevels.h"
+
+#include "DisableWarnings.h"
+
+#include <algorithm>
 #include <iterator>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(LocatorManager* p) { return p; }
-IceUtil::Shared* IceInternal::upCast(LocatorInfo* p) { return p; }
-IceUtil::Shared* IceInternal::upCast(LocatorTable* p) { return p; }
-
 namespace
 {
-
-class ObjectRequest : public LocatorInfo::Request
-{
-public:
-
-    ObjectRequest(const LocatorInfoPtr& locatorInfo, const ReferencePtr& ref) : LocatorInfo::Request(locatorInfo, ref)
-    {
-        assert(ref->isWellKnown());
-    }
-
-    virtual void send()
+    class ObjectRequest final : public LocatorInfo::Request, public std::enable_shared_from_this<ObjectRequest>
     {
-        try
+    public:
+        ObjectRequest(const LocatorInfoPtr& locatorInfo, const ReferencePtr& ref)
+            : LocatorInfo::Request(locatorInfo, ref)
         {
-#ifdef ICE_CPP11_MAPPING
-            LocatorInfo::RequestPtr request = this;
-            _locatorInfo->getLocator()->findObjectByIdAsync(
-                _reference->getIdentity(),
-                [request](const ObjectPrxPtr& object)
-                {
-                    request->response(object);
-                },
-                [request](exception_ptr e)
-                {
-                    try
-                    {
-                        rethrow_exception(e);
-                    }
-                    catch(const Exception& ex)
-                    {
-                        request->exception(ex);
-                    }
-                });
-#else
-            _locatorInfo->getLocator()->begin_findObjectById(
-                _reference->getIdentity(),
-                newCallback_Locator_findObjectById(static_cast<LocatorInfo::Request*>(this),
-                                                   &LocatorInfo::Request::response,
-                                                   &LocatorInfo::Request::exception));
-#endif
+            assert(ref->isWellKnown());
         }
-        catch(const Ice::Exception& ex)
+
+        void send() override
         {
-            exception(ex);
+            try
+            {
+                LocatorInfo::RequestPtr request = shared_from_this();
+                _locatorInfo->getLocator()->findObjectByIdAsync(
+                    _reference->getIdentity(),
+                    [request](const optional<ObjectPrx>& object) { request->response(object); },
+                    [request](exception_ptr e) { request->exception(e); });
+            }
+            catch (const Ice::Exception&)
+            {
+                exception(current_exception());
+            }
         }
-    }
-};
-
-class AdapterRequest : public LocatorInfo::Request
-{
-public:
-
-    AdapterRequest(const LocatorInfoPtr& locatorInfo, const ReferencePtr& ref) : LocatorInfo::Request(locatorInfo, ref)
-    {
-        assert(ref->isIndirect() && !ref->isWellKnown());
-    }
+    };
 
-    virtual void send()
+    class AdapterRequest final : public LocatorInfo::Request, public std::enable_shared_from_this<AdapterRequest>
     {
-        try
+    public:
+        AdapterRequest(const LocatorInfoPtr& locatorInfo, const ReferencePtr& ref)
+            : LocatorInfo::Request(locatorInfo, ref)
         {
-#ifdef ICE_CPP11_MAPPING
-            LocatorInfo::RequestPtr request = this;
-            _locatorInfo->getLocator()->findAdapterByIdAsync(_reference->getAdapterId(),
-                [request](const shared_ptr<Ice::ObjectPrx>& object)
-                {
-                    request->response(object);
-                },
-                [request](exception_ptr e)
-                {
-                    try
-                    {
-                        rethrow_exception(e);
-                    }
-                    catch(const Exception& ex)
-                    {
-                        request->exception(ex);
-                    }
-                });
-#else
-            _locatorInfo->getLocator()->begin_findAdapterById(
-                _reference->getAdapterId(),
-                newCallback_Locator_findAdapterById(static_cast<LocatorInfo::Request*>(this),
-                                                    &LocatorInfo::Request::response,
-                                                    &LocatorInfo::Request::exception));
-#endif
+            assert(ref->isIndirect() && !ref->isWellKnown());
         }
-        catch(const Ice::Exception& ex)
+
+        void send() override
         {
-            exception(ex);
+            try
+            {
+                LocatorInfo::RequestPtr request = shared_from_this();
+                _locatorInfo->getLocator()->findAdapterByIdAsync(
+                    _reference->getAdapterId(),
+                    [request](const optional<ObjectPrx>& object) { request->response(object); },
+                    [request](exception_ptr e) { request->exception(e); });
+            }
+            catch (const Ice::Exception&)
+            {
+                exception(current_exception());
+            }
         }
-    }
-};
-
+    };
 }
 
-IceInternal::LocatorManager::LocatorManager(const Ice::PropertiesPtr& properties) :
-    _background(properties->getPropertyAsInt("Ice.BackgroundLocatorCacheUpdates") > 0),
-    _tableHint(_table.end())
+IceInternal::LocatorManager::LocatorManager(const Ice::PropertiesPtr& properties)
+    : _background(properties->getIcePropertyAsInt("Ice.BackgroundLocatorCacheUpdates") > 0),
+      _tableHint(_table.end())
 {
 }
 
 void
 IceInternal::LocatorManager::destroy()
 {
-    IceUtil::Mutex::Lock sync(*this);
-
-#ifdef ICE_CPP11_COMPILER
-    for_each(_table.begin(), _table.end(), [](pair<Ice::LocatorPrxPtr, LocatorInfoPtr> it){ it.second->destroy(); });
-#else
-    for_each(_table.begin(), _table.end(), Ice::secondVoidMemFun<const LocatorPrx, LocatorInfo>(&LocatorInfo::destroy));
-#endif
+    lock_guard lock(_mutex);
+    for (const auto& [_, locatorInfo] : _table)
+    {
+        locatorInfo->destroy();
+    }
     _table.clear();
     _tableHint = _table.end();
 
@@ -145,37 +96,32 @@ IceInternal::LocatorManager::destroy()
 }
 
 LocatorInfoPtr
-IceInternal::LocatorManager::get(const LocatorPrxPtr& loc)
+IceInternal::LocatorManager::get(const LocatorPrx& loc)
 {
-    if(!loc)
-    {
-        return 0;
-    }
-
-    LocatorPrxPtr locator = loc->ice_locator(0); // The locator can't be located.
+    LocatorPrx locator = loc->ice_locator(nullopt); // The locator can't be located.
 
     //
     // TODO: reap unused locator info objects?
     //
 
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    LocatorInfoTable::iterator p = _table.end();
+    auto p = _table.end();
 
-    if(_tableHint != _table.end())
+    if (_tableHint != _table.end())
     {
-        if(targetEqualTo(_tableHint->first, locator))
+        if (_tableHint->first == locator)
         {
             p = _tableHint;
         }
     }
 
-    if(p == _table.end())
+    if (p == _table.end())
     {
         p = _table.find(locator);
     }
 
-    if(p == _table.end())
+    if (p == _table.end())
     {
         //
         // Rely on locator identity for the adapter table. We want to
@@ -183,18 +129,17 @@ IceInternal::LocatorManager::get(const LocatorPrxPtr& loc)
         // proxy).
         //
         pair<Identity, EncodingVersion> locatorKey(locator->ice_getIdentity(), locator->ice_getEncodingVersion());
-        map<pair<Identity, EncodingVersion>, LocatorTablePtr>::iterator t = _locatorTables.find(locatorKey);
-        if(t == _locatorTables.end())
+        auto t = _locatorTables.find(locatorKey);
+        if (t == _locatorTables.end())
         {
-            t = _locatorTables.insert(_locatorTables.begin(),
-                                      pair<const pair<Identity, EncodingVersion>, LocatorTablePtr>(
-                                          locatorKey, new LocatorTable()));
+            t = _locatorTables.insert(
+                _locatorTables.begin(),
+                pair<const pair<Identity, EncodingVersion>, LocatorTablePtr>(locatorKey, new LocatorTable()));
         }
 
-        _tableHint = _table.insert(_tableHint,
-                                   pair<const LocatorPrxPtr, LocatorInfoPtr>(locator,
-                                                                          new LocatorInfo(locator, t->second,
-                                                                                          _background)));
+        _tableHint = _table.insert(
+            _tableHint,
+            pair<const LocatorPrx, LocatorInfoPtr>(locator, new LocatorInfo(locator, t->second, _background)));
     }
     else
     {
@@ -204,32 +149,33 @@ IceInternal::LocatorManager::get(const LocatorPrxPtr& loc)
     return _tableHint->second;
 }
 
-IceInternal::LocatorTable::LocatorTable()
-{
-}
+IceInternal::LocatorTable::LocatorTable() = default;
 
 void
 IceInternal::LocatorTable::clear()
 {
-     IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-     _adapterEndpointsMap.clear();
-     _objectMap.clear();
+    _adapterEndpointsMap.clear();
+    _objectMap.clear();
 }
 
 bool
-IceInternal::LocatorTable::getAdapterEndpoints(const string& adapter, int ttl, vector<EndpointIPtr>& endpoints)
+IceInternal::LocatorTable::getAdapterEndpoints(
+    const string& adapter,
+    chrono::milliseconds ttl,
+    vector<EndpointIPtr>& endpoints)
 {
-    if(ttl == 0) // No locator cache.
+    if (ttl == 0ms) // No locator cache.
     {
         return false;
     }
 
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    map<string, pair<IceUtil::Time, vector<EndpointIPtr> > >::iterator p = _adapterEndpointsMap.find(adapter);
+    auto p = _adapterEndpointsMap.find(adapter);
 
-    if(p != _adapterEndpointsMap.end())
+    if (p != _adapterEndpointsMap.end())
     {
         endpoints = p->second.second;
         return checkTTL(p->second.first, ttl);
@@ -240,30 +186,29 @@ IceInternal::LocatorTable::getAdapterEndpoints(const string& adapter, int ttl, v
 void
 IceInternal::LocatorTable::addAdapterEndpoints(const string& adapter, const vector<EndpointIPtr>& endpoints)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    map<string, pair<IceUtil::Time, vector<EndpointIPtr> > >::iterator p = _adapterEndpointsMap.find(adapter);
+    auto p = _adapterEndpointsMap.find(adapter);
 
-    if(p != _adapterEndpointsMap.end())
+    if (p != _adapterEndpointsMap.end())
     {
-        p->second = make_pair(IceUtil::Time::now(IceUtil::Time::Monotonic), endpoints);
+        p->second = make_pair(chrono::steady_clock::now(), endpoints);
     }
     else
     {
-        _adapterEndpointsMap.insert(
-            make_pair(adapter, make_pair(IceUtil::Time::now(IceUtil::Time::Monotonic), endpoints)));
+        _adapterEndpointsMap.insert(make_pair(adapter, make_pair(chrono::steady_clock::now(), endpoints)));
     }
 }
 
 vector<EndpointIPtr>
 IceInternal::LocatorTable::removeAdapterEndpoints(const string& adapter)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    map<string, pair<IceUtil::Time, vector<EndpointIPtr> > >::iterator p = _adapterEndpointsMap.find(adapter);
-    if(p == _adapterEndpointsMap.end())
+    auto p = _adapterEndpointsMap.find(adapter);
+    if (p == _adapterEndpointsMap.end())
     {
-        return vector<EndpointIPtr>();
+        return {};
     }
 
     vector<EndpointIPtr> endpoints = p->second.second;
@@ -274,18 +219,17 @@ IceInternal::LocatorTable::removeAdapterEndpoints(const string& adapter)
 }
 
 bool
-IceInternal::LocatorTable::getObjectReference(const Identity& id, int ttl, ReferencePtr& ref)
+IceInternal::LocatorTable::getObjectReference(const Identity& id, chrono::milliseconds ttl, ReferencePtr& ref)
 {
-    if(ttl == 0) // No locator cache
+    if (ttl == 0ms) // No locator cache
     {
         return false;
     }
 
-    IceUtil::Mutex::Lock sync(*this);
-
-    map<Identity, pair<IceUtil::Time, ReferencePtr> >::iterator p = _objectMap.find(id);
+    lock_guard lock(_mutex);
 
-    if(p != _objectMap.end())
+    auto p = _objectMap.find(id);
+    if (p != _objectMap.end())
     {
         ref = p->second.second;
         return checkTTL(p->second.first, ttl);
@@ -296,29 +240,29 @@ IceInternal::LocatorTable::getObjectReference(const Identity& id, int ttl, Refer
 void
 IceInternal::LocatorTable::addObjectReference(const Identity& id, const ReferencePtr& ref)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    map<Identity, pair<IceUtil::Time, ReferencePtr> >::iterator p = _objectMap.find(id);
+    auto p = _objectMap.find(id);
 
-    if(p != _objectMap.end())
+    if (p != _objectMap.end())
     {
-        p->second = make_pair(IceUtil::Time::now(IceUtil::Time::Monotonic), ref);
+        p->second = make_pair(chrono::steady_clock::now(), ref);
     }
     else
     {
-        _objectMap.insert(make_pair(id, make_pair(IceUtil::Time::now(IceUtil::Time::Monotonic), ref)));
+        _objectMap.insert(make_pair(id, make_pair(chrono::steady_clock::now(), ref)));
     }
 }
 
 ReferencePtr
 IceInternal::LocatorTable::removeObjectReference(const Identity& id)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    map<Identity, pair<IceUtil::Time, ReferencePtr> >::iterator p = _objectMap.find(id);
-    if(p == _objectMap.end())
+    auto p = _objectMap.find(id);
+    if (p == _objectMap.end())
     {
-        return 0;
+        return nullptr;
     }
 
     ReferencePtr ref = p->second.second;
@@ -327,27 +271,27 @@ IceInternal::LocatorTable::removeObjectReference(const Identity& id)
 }
 
 bool
-IceInternal::LocatorTable::checkTTL(const IceUtil::Time& time, int ttl) const
+IceInternal::LocatorTable::checkTTL(const chrono::steady_clock::time_point& time, chrono::milliseconds ttl) const
 {
-    assert(ttl != 0);
-    if (ttl < 0) // TTL = infinite
+    assert(ttl != 0ms);
+    if (ttl < 0ms) // TTL = infinite
     {
         return true;
     }
     else
     {
-        return IceUtil::Time::now(IceUtil::Time::Monotonic) - time <= IceUtil::Time::seconds(ttl);
+        return chrono::steady_clock::now() - time <= ttl;
     }
 }
 
 void
-IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locatorInfo, const Ice::ObjectPrxPtr& proxy)
+IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locatorInfo, const optional<ObjectPrx>& proxy)
 {
     vector<EndpointIPtr> endpoints;
-    if(proxy)
+    if (proxy)
     {
         ReferencePtr r = proxy->_getReference();
-        if(_reference->isWellKnown() && !isSupported(_reference->getEncoding(), r->getEncoding()))
+        if (_reference->isWellKnown() && !isSupported(_reference->getEncoding(), r->getEncoding()))
         {
             //
             // If a well-known proxy and the returned proxy encoding
@@ -355,171 +299,191 @@ IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locato
             // endpoint we can use.
             //
         }
-        else if(!r->isIndirect())
+        else if (!r->isIndirect())
         {
             endpoints = r->getEndpoints();
         }
-        else if(_reference->isWellKnown() && !r->isWellKnown())
+        else if (_reference->isWellKnown() && !r->isWellKnown())
         {
             //
             // We're resolving the endpoints of a well-known object and the proxy returned
             // by the locator is an indirect proxy. We now need to resolve the endpoints
             // of this indirect proxy.
             //
-            if(_reference->getInstance()->traceLevels()->location >= 1)
+            if (_reference->getInstance()->traceLevels()->location >= 1)
             {
-                locatorInfo->trace("retrieved adapter for well-known object from locator, adding to locator cache",
-                                   _reference, r);
+                locatorInfo->trace(
+                    "retrieved adapter for well-known object from locator, adding to locator cache",
+                    _reference,
+                    r);
             }
             locatorInfo->getEndpoints(r, _reference, _ttl, _callback);
             return;
         }
     }
 
-    if(_reference->getInstance()->traceLevels()->location >= 1)
+    if (_reference->getInstance()->traceLevels()->location >= 1)
     {
         locatorInfo->getEndpointsTrace(_reference, endpoints, false);
     }
-    if(_callback)
+    if (_callback)
     {
         _callback->setEndpoints(endpoints, false);
     }
 }
 
 void
-IceInternal::LocatorInfo::RequestCallback::exception(const LocatorInfoPtr& locatorInfo, const Ice::Exception& exc)
+IceInternal::LocatorInfo::RequestCallback::exception(const LocatorInfoPtr& locatorInfo, std::exception_ptr exc)
 {
     try
     {
         locatorInfo->getEndpointsException(_reference, exc); // This throws.
     }
-    catch(const Ice::LocalException& ex)
+    catch (const Ice::LocalException&)
     {
-        if(_callback)
+        if (_callback)
         {
-            _callback->setException(ex);
+            _callback->setException(current_exception());
         }
     }
 }
 
-IceInternal::LocatorInfo::RequestCallback::RequestCallback(const ReferencePtr& ref,
-                                                           int ttl,
-                                                           const GetEndpointsCallbackPtr& cb) :
-    _reference(ref),  _ttl(ttl), _callback(cb)
+IceInternal::LocatorInfo::RequestCallback::RequestCallback(
+    ReferencePtr ref,
+    chrono::milliseconds ttl,
+    GetEndpointsCallbackPtr cb)
+    : _reference(std::move(ref)),
+      _ttl(ttl),
+      _callback(std::move(cb))
 {
 }
 
 void
-IceInternal::LocatorInfo::Request::addCallback(const ReferencePtr& ref,
-                                               const ReferencePtr& wellKnownRef,
-                                               int ttl,
-                                               const GetEndpointsCallbackPtr& cb)
+IceInternal::LocatorInfo::Request::addCallback(
+    const ReferencePtr& ref,
+    const ReferencePtr& wellKnownRef,
+    chrono::milliseconds ttl,
+    const GetEndpointsCallbackPtr& cb)
 {
-    RequestCallbackPtr callback = new RequestCallback(ref, ttl, cb);
+    RequestCallbackPtr callback = make_shared<RequestCallback>(ref, ttl, cb);
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-        if(!_response && !_exception)
+        unique_lock lock(_mutex);
+        if (!_response && !_exception)
         {
             _callbacks.push_back(callback);
-            if(wellKnownRef) // This request is to resolve the endpoints of a cached well-known object reference
+            if (wellKnownRef) // This request is to resolve the endpoints of a cached well-known object reference
             {
                 _wellKnownRefs.push_back(wellKnownRef);
             }
-            if(!_sent)
+            if (!_sent)
             {
                 _sent = true;
-                sync.release();
-                send(); // send() might call exception() from this thread so we need to release the mutex.
+                lock.unlock();
+                send(); // send() might call exception() from this thread so we need to unlock the mutex.
             }
             return;
         }
     }
 
-    if(_response)
+    if (_response)
     {
         callback->response(_locatorInfo, _proxy);
     }
     else
     {
         assert(_exception);
-        callback->exception(_locatorInfo, *_exception);
+        callback->exception(_locatorInfo, _exception);
     }
 }
 
-IceInternal::LocatorInfo::Request::Request(const LocatorInfoPtr& locatorInfo, const ReferencePtr& ref) :
-    _locatorInfo(locatorInfo), _reference(ref), _sent(false), _response(false)
+IceInternal::LocatorInfo::GetEndpointsCallback::~GetEndpointsCallback() = default; // avoid weak vtable
+
+IceInternal::LocatorInfo::Request::Request(LocatorInfoPtr locatorInfo, ReferencePtr ref)
+    : _locatorInfo(std::move(locatorInfo)),
+      _reference(std::move(ref))
 {
 }
 
+IceInternal::LocatorInfo::Request::~Request() = default; // avoid weak vtable
+
 void
-IceInternal::LocatorInfo::Request::response(const Ice::ObjectPrxPtr& proxy)
+IceInternal::LocatorInfo::Request::response(const optional<ObjectPrx>& proxy)
 {
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
+        lock_guard lock(_mutex);
         _locatorInfo->finishRequest(_reference, _wellKnownRefs, proxy, false);
         _response = true;
         _proxy = proxy;
-        _monitor.notifyAll();
     }
-    for(vector<RequestCallbackPtr>::const_iterator p = _callbacks.begin(); p != _callbacks.end(); ++p)
+    for (const auto& callback : _callbacks)
     {
-        (*p)->response(_locatorInfo, proxy);
+        callback->response(_locatorInfo, proxy);
     }
 }
 
 void
-IceInternal::LocatorInfo::Request::exception(const Ice::Exception& ex)
+IceInternal::LocatorInfo::Request::exception(std::exception_ptr ex)
 {
+    bool isUserException = false;
+    try
+    {
+        rethrow_exception(ex);
+    }
+    catch (const Ice::UserException&)
+    {
+        isUserException = true;
+    }
+    catch (...)
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-        _locatorInfo->finishRequest(_reference, _wellKnownRefs, 0, dynamic_cast<const Ice::UserException*>(&ex));
+    }
 
-        ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone());
-        _monitor.notifyAll();
+    {
+        lock_guard lock(_mutex);
+        _locatorInfo->finishRequest(_reference, _wellKnownRefs, nullopt, isUserException);
+        _exception = ex;
     }
-    for(vector<RequestCallbackPtr>::const_iterator p = _callbacks.begin(); p != _callbacks.end(); ++p)
+    for (const auto& callback : _callbacks)
     {
-        (*p)->exception(_locatorInfo, ex);
+        callback->exception(_locatorInfo, ex);
     }
 }
 
-IceInternal::LocatorInfo::LocatorInfo(const LocatorPrxPtr& locator, const LocatorTablePtr& table, bool background) :
-    _locator(locator),
-    _table(table),
-    _background(background)
+IceInternal::LocatorInfo::LocatorInfo(LocatorPrx locator, LocatorTablePtr table, bool background)
+    : _locator(std::move(locator)),
+      _table(std::move(table)),
+      _background(background)
 {
-    assert(_locator);
     assert(_table);
 }
 
 void
 IceInternal::LocatorInfo::destroy()
 {
-    IceUtil::Mutex::Lock sync(*this);
-
-    _locatorRegistry = 0;
+    lock_guard lock(_mutex);
+    _locatorRegistry = nullopt;
     _table->clear();
 }
 
 bool
 IceInternal::LocatorInfo::operator==(const LocatorInfo& rhs) const
 {
-    return Ice::targetEqualTo(_locator, rhs._locator);
+    return _locator == rhs._locator;
 }
 
 bool
 IceInternal::LocatorInfo::operator<(const LocatorInfo& rhs) const
 {
-    return Ice::targetLess(_locator, rhs._locator);
+    return _locator < rhs._locator;
 }
 
-LocatorRegistryPrxPtr
+optional<LocatorRegistryPrx>
 IceInternal::LocatorInfo::getLocatorRegistry()
 {
     {
-        IceUtil::Mutex::Lock sync(*this);
-        if(_locatorRegistry)
+        lock_guard lock(_mutex);
+        if (_locatorRegistry)
         {
+            // We don't cache the "no locator registry" result.
             return _locatorRegistry;
         }
     }
@@ -527,40 +491,42 @@ IceInternal::LocatorInfo::getLocatorRegistry()
     //
     // Do not make locator calls from within sync.
     //
-    LocatorRegistryPrxPtr locatorRegistry = _locator->getRegistry();
-    if(!locatorRegistry)
+    optional<LocatorRegistryPrx> locatorRegistry = _locator->getRegistry();
+    if (!locatorRegistry)
     {
-        return 0;
+        return nullopt;
     }
 
     {
-        IceUtil::Mutex::Lock sync(*this);
+        lock_guard lock(_mutex);
 
         //
         // The locator registry can't be located. We use ordered
         // endpoint selection in case the locator returned a proxy
-        // with some endpoints which are prefered to be tried first.
+        // with some endpoints which are preferred to be tried first.
         //
-        _locatorRegistry = locatorRegistry->ice_locator(0)->ice_endpointSelection(Ice::ICE_ENUM(EndpointSelectionType, Ordered));
+        _locatorRegistry =
+            locatorRegistry->ice_locator(nullopt)->ice_endpointSelection(Ice::EndpointSelectionType::Ordered);
         return _locatorRegistry;
     }
 }
 
 void
-IceInternal::LocatorInfo::getEndpoints(const ReferencePtr& ref,
-                                       const ReferencePtr& wellKnownRef,
-                                       int ttl,
-                                       const GetEndpointsCallbackPtr& callback)
+IceInternal::LocatorInfo::getEndpoints(
+    const ReferencePtr& ref,
+    const ReferencePtr& wellKnownRef,
+    chrono::milliseconds ttl,
+    const GetEndpointsCallbackPtr& callback)
 {
     assert(ref->isIndirect());
     vector<EndpointIPtr> endpoints;
-    if(!ref->isWellKnown())
+    if (!ref->isWellKnown())
     {
-        if(!_table->getAdapterEndpoints(ref->getAdapterId(), ttl, endpoints))
+        if (!_table->getAdapterEndpoints(ref->getAdapterId(), ttl, endpoints))
         {
-            if(_background && !endpoints.empty())
+            if (_background && !endpoints.empty())
             {
-                getAdapterRequest(ref)->addCallback(ref, wellKnownRef, ttl, 0);
+                getAdapterRequest(ref)->addCallback(ref, wellKnownRef, ttl, nullptr);
             }
             else
             {
@@ -572,26 +538,26 @@ IceInternal::LocatorInfo::getEndpoints(const ReferencePtr& ref,
     else
     {
         ReferencePtr r;
-        if(!_table->getObjectReference(ref->getIdentity(), ttl, r))
+        if (!_table->getObjectReference(ref->getIdentity(), ttl, r))
         {
-            if(_background && r)
+            if (_background && r)
             {
-                getObjectRequest(ref)->addCallback(ref, 0, ttl, 0);
+                getObjectRequest(ref)->addCallback(ref, nullptr, ttl, nullptr);
             }
             else
             {
-                getObjectRequest(ref)->addCallback(ref, 0, ttl, callback);
+                getObjectRequest(ref)->addCallback(ref, nullptr, ttl, callback);
                 return;
             }
         }
 
-        if(!r->isIndirect())
+        if (!r->isIndirect())
         {
             endpoints = r->getEndpoints();
         }
-        else if(!r->isWellKnown())
+        else if (!r->isWellKnown())
         {
-            if(ref->getInstance()->traceLevels()->location >= 1)
+            if (ref->getInstance()->traceLevels()->location >= 1)
             {
                 trace("found adapter for well-known object in locator cache", ref, r);
             }
@@ -601,11 +567,11 @@ IceInternal::LocatorInfo::getEndpoints(const ReferencePtr& ref,
     }
 
     assert(!endpoints.empty());
-    if(ref->getInstance()->traceLevels()->location >= 1)
+    if (ref->getInstance()->traceLevels()->location >= 1)
     {
         getEndpointsTrace(ref, endpoints, true);
     }
-    if(callback)
+    if (callback)
     {
         callback->setEndpoints(endpoints, true);
     }
@@ -616,11 +582,11 @@ IceInternal::LocatorInfo::clearCache(const ReferencePtr& ref)
 {
     assert(ref->isIndirect());
 
-    if(!ref->isWellKnown())
+    if (!ref->isWellKnown())
     {
         vector<EndpointIPtr> endpoints = _table->removeAdapterEndpoints(ref->getAdapterId());
 
-        if(!endpoints.empty() && ref->getInstance()->traceLevels()->location >= 2)
+        if (!endpoints.empty() && ref->getInstance()->traceLevels()->location >= 2)
         {
             trace("removed endpoints for adapter from locator cache", ref, endpoints);
         }
@@ -628,18 +594,18 @@ IceInternal::LocatorInfo::clearCache(const ReferencePtr& ref)
     else
     {
         ReferencePtr r = _table->removeObjectReference(ref->getIdentity());
-        if(r)
+        if (r)
         {
-            if(!r->isIndirect())
+            if (!r->isIndirect())
             {
-                if(ref->getInstance()->traceLevels()->location >= 2)
+                if (ref->getInstance()->traceLevels()->location >= 2)
                 {
                     trace("removed endpoints for well-known object from locator cache", ref, r->getEndpoints());
                 }
             }
-            else if(!r->isWellKnown())
+            else if (!r->isWellKnown())
             {
-                if(ref->getInstance()->traceLevels()->location >= 2)
+                if (ref->getInstance()->traceLevels()->location >= 2)
                 {
                     trace("removed adapter for well-known object from locator cache", ref, r);
                 }
@@ -650,51 +616,53 @@ IceInternal::LocatorInfo::clearCache(const ReferencePtr& ref)
 }
 
 void
-IceInternal::LocatorInfo::getEndpointsException(const ReferencePtr& ref, const Ice::Exception& exc)
+IceInternal::LocatorInfo::getEndpointsException(const ReferencePtr& ref, std::exception_ptr exc)
 {
     assert(ref->isIndirect());
 
     try
     {
-        exc.ice_throw();
+        rethrow_exception(exc);
     }
-    catch(const AdapterNotFoundException&)
+    catch (const AdapterNotFoundException&)
     {
-        if(ref->getInstance()->traceLevels()->location >= 1)
+        if (ref->getInstance()->traceLevels()->location >= 1)
         {
-            Trace out(ref->getInstance()->initializationData().logger,
-                      ref->getInstance()->traceLevels()->locationCat);
-            out << "adapter not found" << "\n";
+            Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
+            out << "adapter not found"
+                << "\n";
             out << "adapter = " << ref->getAdapterId();
         }
 
         throw NotRegisteredException(__FILE__, __LINE__, "object adapter", ref->getAdapterId());
     }
-    catch(const ObjectNotFoundException&)
+    catch (const ObjectNotFoundException&)
     {
-        if(ref->getInstance()->traceLevels()->location >= 1)
+        if (ref->getInstance()->traceLevels()->location >= 1)
         {
-            Trace out(ref->getInstance()->initializationData().logger,
-                      ref->getInstance()->traceLevels()->locationCat);
-            out << "object not found" << "\n";
-            out << "object = " << Ice::identityToString(ref->getIdentity(),
-                                                        ref->getInstance()->toStringMode());
+            Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
+            out << "object not found"
+                << "\n";
+            out << "object = " << Ice::identityToString(ref->getIdentity(), ref->getInstance()->toStringMode());
         }
 
-        throw NotRegisteredException(__FILE__, __LINE__, "object",
-                                     Ice::identityToString(ref->getIdentity(), ref->getInstance()->toStringMode()));
+        throw NotRegisteredException(
+            __FILE__,
+            __LINE__,
+            "object",
+            Ice::identityToString(ref->getIdentity(), ref->getInstance()->toStringMode()));
     }
-    catch(const NotRegisteredException&)
+    catch (const NotRegisteredException&)
     {
         throw;
     }
-    catch(const LocalException& ex)
+    catch (const LocalException& ex)
     {
-        if(ref->getInstance()->traceLevels()->location >= 1)
+        if (ref->getInstance()->traceLevels()->location >= 1)
         {
             Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
             out << "couldn't contact the locator to retrieve endpoints\n";
-            if(ref->getAdapterId().empty())
+            if (ref->getAdapterId().empty())
             {
                 out << "well-known proxy = " << ref->toString() << "\n";
             }
@@ -709,15 +677,13 @@ IceInternal::LocatorInfo::getEndpointsException(const ReferencePtr& ref, const I
 }
 
 void
-IceInternal::LocatorInfo::getEndpointsTrace(const ReferencePtr& ref,
-                                            const vector<EndpointIPtr>& endpoints,
-                                            bool cached)
+IceInternal::LocatorInfo::getEndpointsTrace(const ReferencePtr& ref, const vector<EndpointIPtr>& endpoints, bool cached)
 {
-    if(!endpoints.empty())
+    if (!endpoints.empty())
     {
-        if(cached)
+        if (cached)
         {
-            if(ref->isWellKnown())
+            if (ref->isWellKnown())
             {
                 trace("found endpoints for well-known proxy in locator cache", ref, endpoints);
             }
@@ -728,7 +694,7 @@ IceInternal::LocatorInfo::getEndpointsTrace(const ReferencePtr& ref,
         }
         else
         {
-            if(ref->isWellKnown())
+            if (ref->isWellKnown())
             {
                 trace("retrieved endpoints for well-known proxy from locator, adding to locator cache", ref, endpoints);
             }
@@ -742,7 +708,7 @@ IceInternal::LocatorInfo::getEndpointsTrace(const ReferencePtr& ref,
     {
         Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
         out << "no endpoints configured for ";
-        if(ref->getAdapterId().empty())
+        if (ref->getAdapterId().empty())
         {
             out << "well-known object\n";
             out << "well-known proxy = " << ref->toString();
@@ -762,27 +728,22 @@ IceInternal::LocatorInfo::trace(const string& msg, const ReferencePtr& ref, cons
 
     Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
     out << msg << '\n';
-    if(!ref->isWellKnown())
+    if (!ref->isWellKnown())
     {
-        out << "adapter = "  << ref->getAdapterId() << '\n';
+        out << "adapter = " << ref->getAdapterId() << '\n';
     }
     else
     {
-        out << "well-known proxy = "  << ref->toString() << '\n';
+        out << "well-known proxy = " << ref->toString() << '\n';
     }
 
     const char* sep = endpoints.size() > 1 ? ":" : "";
     ostringstream o;
-#ifdef ICE_CPP11_COMPILER
-    transform(endpoints.begin(), endpoints.end(), ostream_iterator<string>(o, sep),
-              [](const EndpointPtr& endpoint)
-              {
-                  return endpoint->toString();
-              });
-#else
-    transform(endpoints.begin(), endpoints.end(), ostream_iterator<string>(o, sep),
-              Ice::constMemFun(&Endpoint::toString));
-#endif
+    transform(
+        endpoints.begin(),
+        endpoints.end(),
+        ostream_iterator<string>(o, sep),
+        [](const EndpointPtr& endpoint) { return endpoint->toString(); });
     out << "endpoints = " << o.str();
 }
 
@@ -793,27 +754,27 @@ IceInternal::LocatorInfo::trace(const string& msg, const ReferencePtr& ref, cons
 
     Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
     out << msg << '\n';
-    out << "well-known proxy = "  << ref->toString() << '\n';
+    out << "well-known proxy = " << ref->toString() << '\n';
     out << "adapter = " << resolved->getAdapterId();
 }
 
 IceInternal::LocatorInfo::RequestPtr
 IceInternal::LocatorInfo::getAdapterRequest(const ReferencePtr& ref)
 {
-    IceUtil::Mutex::Lock sync(*this);
-    if(ref->getInstance()->traceLevels()->location >= 1)
+    lock_guard lock(_mutex);
+    if (ref->getInstance()->traceLevels()->location >= 1)
     {
         Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
         out << "searching for adapter by id\nadapter = " << ref->getAdapterId();
     }
 
-    map<string, RequestPtr>::const_iterator p = _adapterRequests.find(ref->getAdapterId());
-    if(p != _adapterRequests.end())
+    auto p = _adapterRequests.find(ref->getAdapterId());
+    if (p != _adapterRequests.end())
     {
         return p->second;
     }
 
-    RequestPtr request = new AdapterRequest(this, ref);
+    RequestPtr request = make_shared<AdapterRequest>(shared_from_this(), ref);
     _adapterRequests.insert(make_pair(ref->getAdapterId(), request));
     return request;
 }
@@ -821,68 +782,69 @@ IceInternal::LocatorInfo::getAdapterRequest(const ReferencePtr& ref)
 IceInternal::LocatorInfo::RequestPtr
 IceInternal::LocatorInfo::getObjectRequest(const ReferencePtr& ref)
 {
-    IceUtil::Mutex::Lock sync(*this);
-    if(ref->getInstance()->traceLevels()->location >= 1)
+    lock_guard lock(_mutex);
+    if (ref->getInstance()->traceLevels()->location >= 1)
     {
         Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
         out << "searching for well-known object\nwell-known proxy = " << ref->toString();
     }
 
-    map<Ice::Identity, RequestPtr>::const_iterator p = _objectRequests.find(ref->getIdentity());
-    if(p != _objectRequests.end())
+    auto p = _objectRequests.find(ref->getIdentity());
+    if (p != _objectRequests.end())
     {
         return p->second;
     }
-    RequestPtr request = new ObjectRequest(this, ref);
+    RequestPtr request = make_shared<ObjectRequest>(shared_from_this(), ref);
     _objectRequests.insert(make_pair(ref->getIdentity(), request));
     return request;
 }
 
 void
-IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref,
-                                        const vector<ReferencePtr>& wellKnownRefs,
-                                        const Ice::ObjectPrxPtr& proxy,
-                                        bool notRegistered)
+IceInternal::LocatorInfo::finishRequest(
+    const ReferencePtr& ref,
+    const vector<ReferencePtr>& wellKnownRefs,
+    const std::optional<Ice::ObjectPrx>& proxy,
+    bool notRegistered)
 {
-    if(!proxy || proxy->_getReference()->isIndirect())
+    if (!proxy || proxy->_getReference()->isIndirect())
     {
         //
         // Remove the cached references of well-known objects for which we tried
         // to resolved the endpoints if these endpoints are empty.
         //
-        for(vector<ReferencePtr>::const_iterator q = wellKnownRefs.begin(); q != wellKnownRefs.end(); ++q)
+        for (const auto& wellKnownRef : wellKnownRefs)
         {
-            _table->removeObjectReference((*q)->getIdentity());
+            _table->removeObjectReference(wellKnownRef->getIdentity());
         }
     }
 
-    if(!ref->isWellKnown())
+    if (!ref->isWellKnown())
     {
-        if(proxy && !proxy->_getReference()->isIndirect()) // Cache the adapter endpoints.
+        if (proxy && !proxy->_getReference()->isIndirect()) // Cache the adapter endpoints.
         {
             _table->addAdapterEndpoints(ref->getAdapterId(), proxy->_getReference()->getEndpoints());
         }
-        else if(notRegistered) // If the adapter isn't registered anymore, remove it from the cache.
+        else if (notRegistered) // If the adapter isn't registered anymore, remove it from the cache.
         {
             _table->removeAdapterEndpoints(ref->getAdapterId());
         }
 
-        IceUtil::Mutex::Lock sync(*this);
+        lock_guard lock(_mutex);
         assert(_adapterRequests.find(ref->getAdapterId()) != _adapterRequests.end());
         _adapterRequests.erase(ref->getAdapterId());
     }
     else
     {
-        if(proxy && !proxy->_getReference()->isWellKnown()) // Cache the well-known object reference.
+        if (proxy && !proxy->_getReference()->isWellKnown()) // Cache the well-known object reference.
         {
             _table->addObjectReference(ref->getIdentity(), proxy->_getReference());
         }
-        else if(notRegistered) // If the well-known object isn't registered anymore, remove it from the cache.
+        else if (notRegistered) // If the well-known object isn't registered anymore, remove it from the cache.
         {
             _table->removeObjectReference(ref->getIdentity());
         }
 
-        IceUtil::Mutex::Lock sync(*this);
+        lock_guard lock(_mutex);
         assert(_objectRequests.find(ref->getIdentity()) != _objectRequests.end());
         _objectRequests.erase(ref->getIdentity());
     }