zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,41 +1,43 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/UUID.h>
-#include <Ice/ObjectAdapterI.h>
-#include <Ice/CommunicatorI.h>
-#include <Ice/ObjectAdapterFactory.h>
-#include <Ice/Instance.h>
-#include <Ice/Proxy.h>
-#include <Ice/ProxyFactory.h>
-#include <Ice/ReferenceFactory.h>
-#include <Ice/EndpointI.h>
-#include <Ice/EndpointFactoryManager.h>
-#include <Ice/ConnectionFactory.h>
-#include <Ice/ServantManager.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/LocalException.h>
-#include <Ice/Properties.h>
-#include <Ice/Functional.h>
-#include <Ice/LocatorInfo.h>
-#include <Ice/Locator.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/ThreadPool.h>
-#include <Ice/Communicator.h>
-#include <Ice/Router.h>
-#include <Ice/DefaultsAndOverrides.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/PropertyNames.h>
-#include <Ice/ConsoleUtil.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "ObjectAdapterI.h"
+#include "CheckIdentity.h"
+#include "ConnectionFactory.h"
+#include "ConsoleUtil.h"
+#include "DefaultsAndOverrides.h"
+#include "EndpointFactoryManager.h"
+#include "EndpointI.h"
+#include "Ice/Communicator.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Locator.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Properties.h"
+#include "Ice/Proxy.h"
+#include "Ice/ProxyFunctions.h"
+#include "Ice/Router.h"
+#include "Ice/UUID.h"
+#include "Instance.h"
+#include "LocatorInfo.h"
+#include "LoggerMiddleware.h"
+#include "ObjectAdapterFactory.h"
+#include "ObserverMiddleware.h"
+#include "PropertyNames.h"
+#include "PropertyUtil.h"
+#include "ReferenceFactory.h"
+#include "RouterInfo.h"
+#include "ServantManager.h"
+#include "ThreadPool.h"
+#include "TraceLevels.h"
 
 #ifdef _WIN32
-#   include <sys/timeb.h>
+#    include <sys/timeb.h>
 #else
-#   include <sys/time.h>
+#    include <sys/time.h>
 #endif
 
+#include <algorithm>
 #include <iterator>
+#include <stdexcept>
 
 using namespace std;
 using namespace Ice;
@@ -43,40 +45,21 @@ using namespace IceInternal;
 
 namespace
 {
-inline void checkIdentity(const Identity& ident)
-{
-    if(ident.name.empty())
-    {
-        throw IllegalIdentityException(__FILE__, __LINE__, ident);
-    }
-}
+    inline EndpointIPtr toEndpointI(const EndpointPtr& endp) { return dynamic_pointer_cast<EndpointI>(endp); }
 
-inline void checkServant(const ObjectPtr& servant)
-{
-    if(!servant)
-    {
-        throw IllegalServantException(__FILE__, __LINE__, "cannot add null servant to Object Adapter");
-    }
+    string emptyName{};
 }
 
-inline EndpointIPtr toEndpointI(const EndpointPtr& endp)
-{
-    return ICE_DYNAMIC_CAST(EndpointI, endp);
-}
+Ice::ObjectAdapter::~ObjectAdapter() = default; // avoid weak vtable
 
-}
-
-string
-Ice::ObjectAdapterI::getName() const ICE_NOEXCEPT
+const string&
+Ice::ObjectAdapterI::getName() const noexcept
 {
-    //
-    // No mutex lock necessary, _name is immutable.
-    //
-    return _noConfig ? string("") : _name;
+    return _noConfig ? emptyName : _name;
 }
 
 CommunicatorPtr
-Ice::ObjectAdapterI::getCommunicator() const ICE_NOEXCEPT
+Ice::ObjectAdapterI::getCommunicator() const noexcept
 {
     return _communicator;
 }
@@ -86,9 +69,10 @@ Ice::ObjectAdapterI::activate()
 {
     LocatorInfoPtr locatorInfo;
     bool printAdapterReady = false;
+    bool hasPublishedEndpoints = false;
 
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
         checkForDeactivation();
 
@@ -96,18 +80,15 @@ Ice::ObjectAdapterI::activate()
         // If we've previously been initialized we just need to activate the
         // incoming connection factories and we're done.
         //
-        if(_state != StateUninitialized)
+        if (_state != StateUninitialized)
         {
-#ifdef ICE_CPP11_COMPILER
-            for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-                [](const IncomingConnectionFactoryPtr& factory)
-                {
-                    factory->activate();
-                });
-#else
-            for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-                     Ice::voidMemFun(&IncomingConnectionFactory::activate));
-#endif
+            for_each(
+                _incomingConnectionFactories.begin(),
+                _incomingConnectionFactories.end(),
+                [](const IncomingConnectionFactoryPtr& factory) { factory->activate(); });
+
+            _state = StateActive;
+            _conditionVariable.notify_all();
             return;
         }
 
@@ -121,77 +102,65 @@ Ice::ObjectAdapterI::activate()
         _state = StateActivating;
 
         locatorInfo = _locatorInfo;
-        if(!_noConfig)
+        if (!_noConfig)
         {
             PropertiesPtr properties = _instance->initializationData().properties;
-            printAdapterReady = properties->getPropertyAsInt("Ice.PrintAdapterReady") > 0;
+            printAdapterReady = properties->getIcePropertyAsInt("Ice.PrintAdapterReady") > 0;
         }
+        hasPublishedEndpoints = !_publishedEndpoints.empty();
     }
 
-    try
-    {
-        Ice::Identity dummy;
-        dummy.name = "dummy";
-        updateLocatorRegistry(locatorInfo, createDirectProxy(dummy));
-    }
-    catch(const Ice::LocalException&)
+    if (hasPublishedEndpoints)
     {
-        //
-        // If we couldn't update the locator registry, we let the
-        // exception go through and don't activate the adapter to
-        // allow to user code to retry activating the adapter
-        // later.
-        //
+        try
         {
-            IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-            _state = StateUninitialized;
-            notifyAll();
+            updateLocatorRegistry(locatorInfo, createDirectProxy(Identity{.name = "dummy", .category = ""}));
+        }
+        catch (const Ice::LocalException&)
+        {
+            //
+            // If we couldn't update the locator registry, we let the
+            // exception go through and don't activate the adapter to
+            // allow to user code to retry activating the adapter
+            // later.
+            //
+            {
+                lock_guard lock(_mutex);
+                _state = StateUninitialized;
+                _conditionVariable.notify_all();
+            }
+            throw;
         }
-        throw;
     }
 
-    if(printAdapterReady)
+    if (printAdapterReady)
     {
         consoleOut << _name << " ready" << endl;
     }
 
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
         assert(_state == StateActivating);
-
-#ifdef ICE_CPP11_COMPILER
-            for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-                [](const IncomingConnectionFactoryPtr& factory)
-                {
-                    factory->activate();
-                });
-#else
-        for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-                 Ice::voidMemFun(&IncomingConnectionFactory::activate));
-#endif
+        for_each(
+            _incomingConnectionFactories.begin(),
+            _incomingConnectionFactories.end(),
+            [](const IncomingConnectionFactoryPtr& factory) { factory->activate(); });
         _state = StateActive;
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 }
 
 void
 Ice::ObjectAdapterI::hold()
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     checkForDeactivation();
     _state = StateHeld;
-
-#ifdef ICE_CPP11_COMPILER
-    for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-        [](const IncomingConnectionFactoryPtr& factory)
-        {
-            factory->hold();
-        });
-#else
-    for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-             Ice::voidMemFun(&IncomingConnectionFactory::hold));
-#endif
+    for_each(
+        _incomingConnectionFactories.begin(),
+        _incomingConnectionFactories.end(),
+        [](const IncomingConnectionFactoryPtr& factory) { factory->hold(); });
 }
 
 void
@@ -199,155 +168,115 @@ Ice::ObjectAdapterI::waitForHold()
 {
     vector<IncomingConnectionFactoryPtr> incomingConnectionFactories;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
         checkForDeactivation();
 
         incomingConnectionFactories = _incomingConnectionFactories;
     }
 
-#ifdef ICE_CPP11_COMPILER
-    for_each(incomingConnectionFactories.begin(), incomingConnectionFactories.end(),
-        [](const IncomingConnectionFactoryPtr& factory)
-        {
-            factory->waitUntilHolding();
-        });
-#else
-    for_each(incomingConnectionFactories.begin(), incomingConnectionFactories.end(),
-             Ice::constVoidMemFun(&IncomingConnectionFactory::waitUntilHolding));
-#endif
+    for_each(
+        incomingConnectionFactories.begin(),
+        incomingConnectionFactories.end(),
+        [](const IncomingConnectionFactoryPtr& factory) { factory->waitUntilHolding(); });
 }
 
 void
-Ice::ObjectAdapterI::deactivate() ICE_NOEXCEPT
+Ice::ObjectAdapterI::deactivate() noexcept
 {
+    bool hasPublishedEndpoints = false;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        unique_lock lock(_mutex);
 
-        //
-        // Wait for activation to complete. This is necessary to not
-        // get out of order locator updates.
-        //
-        while(_state == StateActivating || _state == StateDeactivating)
-        {
-            wait();
-        }
-        if(_state >= StateDeactivated)
+        // Wait for activation or a previous deactivation to complete.
+        // This is necessary to avoid out of order locator updates.
+        _conditionVariable.wait(lock, [this] { return _state != StateActivating && _state != StateDeactivating; });
+
+        if (_state >= StateDeactivated)
         {
             return;
         }
         _state = StateDeactivating;
+        hasPublishedEndpoints = !_publishedEndpoints.empty();
     }
 
     //
     // NOTE: the router/locator infos and incoming connection
-    // facatory list are immutable at this point.
+    // factory list are immutable at this point.
     //
 
-    try
+    if (hasPublishedEndpoints)
     {
-        if(_routerInfo)
+        try
+        {
+            updateLocatorRegistry(_locatorInfo, nullopt);
+        }
+        catch (const Ice::LocalException&)
         {
             //
-            // Remove entry from the router manager.
-            //
-            _instance->routerManager()->erase(_routerInfo->getRouter());
-
-            //
-            //  Clear this object adapter with the router.
+            // We can't throw exceptions in deactivate so we ignore
+            // failures to update the locator registry.
             //
-            _routerInfo->setAdapter(0);
         }
-
-        updateLocatorRegistry(_locatorInfo, 0);
     }
-    catch(const Ice::LocalException&)
-    {
-        //
-        // We can't throw exceptions in deactivate so we ignore
-        // failures to update the locator registry.
-        //
-    }
-
-#ifdef ICE_CPP11_COMPILER
-    for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-        [](const IncomingConnectionFactoryPtr& factory)
-        {
-            factory->destroy();
-        });
-#else
-    for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-             Ice::voidMemFun(&IncomingConnectionFactory::destroy));
-#endif
 
-    _instance->outgoingConnectionFactory()->removeAdapter(ICE_SHARED_FROM_THIS);
+    for_each(
+        _incomingConnectionFactories.begin(),
+        _incomingConnectionFactories.end(),
+        [](const IncomingConnectionFactoryPtr& factory) { factory->destroy(); });
 
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
         assert(_state == StateDeactivating);
         _state = StateDeactivated;
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 }
 
 void
-Ice::ObjectAdapterI::waitForDeactivate() ICE_NOEXCEPT
+Ice::ObjectAdapterI::waitForDeactivate() noexcept
 {
     vector<IceInternal::IncomingConnectionFactoryPtr> incomingConnectionFactories;
 
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        unique_lock lock(_mutex);
 
         //
         // Wait for deactivation of the adapter itself, and for
         // the return of all direct method calls using this adapter.
         //
-        while((_state < StateDeactivated) || _directCount > 0)
-        {
-            wait();
-        }
-        if(_state > StateDeactivated)
+        _conditionVariable.wait(lock, [this] { return _state >= StateDeactivated && _directCount == 0; });
+        if (_state > StateDeactivated)
         {
             return;
         }
         incomingConnectionFactories = _incomingConnectionFactories;
     }
 
-    //
-    // Now we wait until all incoming connection factories are
-    // finished.
-    //
-#ifdef ICE_CPP11_COMPILER
-    for_each(incomingConnectionFactories.begin(), incomingConnectionFactories.end(),
-        [](const IncomingConnectionFactoryPtr& factory)
-        {
-            factory->waitUntilFinished();
-        });
-#else
-    for_each(incomingConnectionFactories.begin(), incomingConnectionFactories.end(),
-             Ice::voidMemFun(&IncomingConnectionFactory::waitUntilFinished));
-#endif
+    // Now we wait until all incoming connection factories are finished.
+    for_each(
+        incomingConnectionFactories.begin(),
+        incomingConnectionFactories.end(),
+        [](const IncomingConnectionFactoryPtr& factory) { factory->waitUntilFinished(); });
 }
 
 bool
-Ice::ObjectAdapterI::isDeactivated() const ICE_NOEXCEPT
+Ice::ObjectAdapterI::isDeactivated() const noexcept
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     return _state >= StateDeactivated;
 }
 
 void
-Ice::ObjectAdapterI::destroy() ICE_NOEXCEPT
+Ice::ObjectAdapterI::destroy() noexcept
 {
-    //
     // Deactivate and wait for completion.
-    //
     deactivate();
     waitForDeactivate();
 
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        unique_lock lock(_mutex);
         assert(_state >= StateDeactivated);
 
         //
@@ -355,17 +284,25 @@ Ice::ObjectAdapterI::destroy() ICE_NOEXCEPT
         // adapter. Other threads wait for the destruction to be
         // completed.
         //
-        while(_state == StateDestroying)
-        {
-            wait();
-        }
-        if(_state == StateDestroyed)
+        _conditionVariable.wait(lock, [this] { return _state != StateDestroying; });
+        if (_state == StateDestroyed)
         {
             return;
         }
         _state = StateDestroying;
     }
 
+    if (_routerInfo)
+    {
+        // Remove entry from the router manager.
+        _instance->routerManager()->erase(_routerInfo->getRouter());
+
+        // Clear this object adapter with the router.
+        _routerInfo->setAdapter(nullptr);
+    }
+
+    _instance->outgoingConnectionFactory()->removeAdapter(shared_from_this());
+
     //
     // Now it's also time to clean up our servants and servant
     // locators.
@@ -375,19 +312,19 @@ Ice::ObjectAdapterI::destroy() ICE_NOEXCEPT
     //
     // Destroy the thread pool.
     //
-    if(_threadPool)
+    if (_threadPool)
     {
         _threadPool->destroy();
         _threadPool->joinWithAllThreads();
     }
 
-    if(_objectAdapterFactory)
+    if (_objectAdapterFactory)
     {
-        _objectAdapterFactory->removeObjectAdapter(ICE_SHARED_FROM_THIS);
+        _objectAdapterFactory->removeObjectAdapter(shared_from_this());
     }
 
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
         //
         // We're done, now we can throw away all incoming connection
@@ -398,62 +335,81 @@ Ice::ObjectAdapterI::destroy() ICE_NOEXCEPT
         //
         // Remove object references (some of them cyclic).
         //
-        _instance = 0;
-        _threadPool = 0;
-        _routerInfo = 0;
+        _instance = nullptr;
+        _threadPool = nullptr;
+        _routerInfo = nullptr;
         _publishedEndpoints.clear();
-        _locatorInfo = 0;
-        _reference = 0;
-        _objectAdapterFactory = 0;
+        _locatorInfo = nullptr;
+        _reference = nullptr;
+        _objectAdapterFactory = nullptr;
 
         _state = StateDestroyed;
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::add(const ObjectPtr& object, const Identity& ident)
+ObjectAdapterPtr
+Ice::ObjectAdapterI::use(function<ObjectPtr(ObjectPtr)> middlewareFactory)
 {
-    return addFacet(object, ident, "");
+    // This code is not thread-safe and is not supposed to be.
+    if (_dispatchPipeline)
+    {
+        throw InitializationException{__FILE__, __LINE__, "all middleware must be installed before the first dispatch"};
+    }
+
+    _middlewareFactoryStack.push(std::move(middlewareFactory));
+    return shared_from_this();
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::addFacet(const ObjectPtr& object, const Identity& ident, const string& facet)
+ObjectPrx
+Ice::ObjectAdapterI::_add(ObjectPtr object, Identity ident)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    return _addFacet(std::move(object), std::move(ident), "");
+}
 
-    checkForDeactivation();
-    checkServant(object);
-    checkIdentity(ident);
+ObjectPrx
+Ice::ObjectAdapterI::_addFacet(ObjectPtr object, Identity ident, string facet)
+{
+    lock_guard lock(_mutex);
+
+    checkForDestruction();
+    if (!object)
+    {
+        throw std::invalid_argument{"cannot add null servant to Ice object adapter"};
+    }
+    checkIdentity(ident, __FILE__, __LINE__);
 
-    _servantManager->addServant(object, ident, facet);
+    _servantManager->addServant(std::move(object), ident, facet);
 
-    return newProxy(ident, facet);
+    return newProxy(std::move(ident), std::move(facet));
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::addWithUUID(const ObjectPtr& object)
+ObjectPrx
+Ice::ObjectAdapterI::_addWithUUID(ObjectPtr object)
 {
-    return addFacetWithUUID(object, "");
+    return _addFacetWithUUID(std::move(object), "");
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::addFacetWithUUID(const ObjectPtr& object, const string& facet)
+ObjectPrx
+Ice::ObjectAdapterI::_addFacetWithUUID(ObjectPtr object, string facet)
 {
     Identity ident;
     ident.name = Ice::generateUUID();
-    return addFacet(object, ident, facet);
+    return _addFacet(std::move(object), std::move(ident), std::move(facet));
 }
 
 void
-Ice::ObjectAdapterI::addDefaultServant(const ObjectPtr& servant, const string& category)
+Ice::ObjectAdapterI::addDefaultServant(ObjectPtr servant, string category)
 {
-    checkServant(servant);
+    if (!servant)
+    {
+        throw std::invalid_argument{"cannot add null servant to Ice object adapter"};
+    }
 
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
-    _servantManager->addDefaultServant(servant, category);
+    checkForDestruction();
+    _servantManager->addDefaultServant(std::move(servant), std::move(category));
 }
 
 ObjectPtr
@@ -463,12 +419,12 @@ Ice::ObjectAdapterI::remove(const Identity& ident)
 }
 
 ObjectPtr
-Ice::ObjectAdapterI::removeFacet(const Identity& ident, const string& facet)
+Ice::ObjectAdapterI::removeFacet(const Identity& ident, string_view facet)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
-    checkIdentity(ident);
+    checkForDestruction();
+    checkIdentity(ident, __FILE__, __LINE__);
 
     return _servantManager->removeServant(ident, facet);
 }
@@ -476,20 +432,20 @@ Ice::ObjectAdapterI::removeFacet(const Identity& ident, const string& facet)
 FacetMap
 Ice::ObjectAdapterI::removeAllFacets(const Identity& ident)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
-    checkIdentity(ident);
+    checkForDestruction();
+    checkIdentity(ident, __FILE__, __LINE__);
 
     return _servantManager->removeAllFacets(ident);
 }
 
 ObjectPtr
-Ice::ObjectAdapterI::removeDefaultServant(const string& category)
+Ice::ObjectAdapterI::removeDefaultServant(string_view category)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
+    checkForDestruction();
 
     return _servantManager->removeDefaultServant(category);
 }
@@ -501,12 +457,12 @@ Ice::ObjectAdapterI::find(const Identity& ident) const
 }
 
 ObjectPtr
-Ice::ObjectAdapterI::findFacet(const Identity& ident, const string& facet) const
+Ice::ObjectAdapterI::findFacet(const Identity& ident, string_view facet) const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
-    checkIdentity(ident);
+    checkForDestruction();
+    checkIdentity(ident, __FILE__, __LINE__);
 
     return _servantManager->findServant(ident, facet);
 }
@@ -514,200 +470,168 @@ Ice::ObjectAdapterI::findFacet(const Identity& ident, const string& facet) const
 FacetMap
 Ice::ObjectAdapterI::findAllFacets(const Identity& ident) const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
-    checkIdentity(ident);
+    checkForDestruction();
+    checkIdentity(ident, __FILE__, __LINE__);
 
     return _servantManager->findAllFacets(ident);
 }
 
 ObjectPtr
-Ice::ObjectAdapterI::findByProxy(const ObjectPrxPtr& proxy) const
+Ice::ObjectAdapterI::findByProxy(const ObjectPrx& proxy) const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
+    checkForDestruction();
 
     ReferencePtr ref = proxy->_getReference();
     return findFacet(ref->getIdentity(), ref->getFacet());
 }
 
 ObjectPtr
-Ice::ObjectAdapterI::findDefaultServant(const string& category) const
+Ice::ObjectAdapterI::findDefaultServant(string_view category) const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
+    checkForDestruction();
 
     return _servantManager->findDefaultServant(category);
 }
 
 void
-Ice::ObjectAdapterI::addServantLocator(const ServantLocatorPtr& locator, const string& prefix)
+Ice::ObjectAdapterI::addServantLocator(ServantLocatorPtr locator, string prefix)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
+    checkForDestruction();
 
-    _servantManager->addServantLocator(locator, prefix);
+    _servantManager->addServantLocator(std::move(locator), std::move(prefix));
 }
 
 ServantLocatorPtr
-Ice::ObjectAdapterI::removeServantLocator(const string& prefix)
+Ice::ObjectAdapterI::removeServantLocator(string_view prefix)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
+    checkForDestruction();
 
     return _servantManager->removeServantLocator(prefix);
 }
 
 ServantLocatorPtr
-Ice::ObjectAdapterI::findServantLocator(const string& prefix) const
+Ice::ObjectAdapterI::findServantLocator(string_view prefix) const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
+    checkForDestruction();
 
     return _servantManager->findServantLocator(prefix);
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::createProxy(const Identity& ident) const
+const ObjectPtr&
+Ice::ObjectAdapterI::dispatchPipeline() const noexcept
+{
+    lock_guard lock(_mutex);
+    if (!_dispatchPipeline)
+    {
+        _dispatchPipeline = _servantManager;
+        while (!_middlewareFactoryStack.empty())
+        {
+            _dispatchPipeline = _middlewareFactoryStack.top()(std::move(_dispatchPipeline));
+            _middlewareFactoryStack.pop();
+        }
+    }
+    return _dispatchPipeline;
+}
+
+ObjectPrx
+Ice::ObjectAdapterI::_createProxy(Identity ident) const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
-    checkIdentity(ident);
+    checkForDestruction();
+    checkIdentity(ident, __FILE__, __LINE__);
 
-    return newProxy(ident, "");
+    return newProxy(std::move(ident), "");
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::createDirectProxy(const Identity& ident) const
+ObjectPrx
+Ice::ObjectAdapterI::_createDirectProxy(Identity ident) const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
-    checkIdentity(ident);
+    checkForDestruction();
+    checkIdentity(ident, __FILE__, __LINE__);
 
-    return newDirectProxy(ident, "");
+    return newDirectProxy(std::move(ident), "");
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::createIndirectProxy(const Identity& ident) const
+ObjectPrx
+Ice::ObjectAdapterI::_createIndirectProxy(Identity ident) const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
-    checkIdentity(ident);
+    checkForDestruction();
+    checkIdentity(ident, __FILE__, __LINE__);
 
-    return newIndirectProxy(ident, "", _id);
+    return newIndirectProxy(std::move(ident), "", _id);
 }
 
 void
-Ice::ObjectAdapterI::setLocator(const LocatorPrxPtr& locator)
+Ice::ObjectAdapterI::setLocator(optional<LocatorPrx> locator)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-
+    lock_guard lock(_mutex);
     checkForDeactivation();
-
-    _locatorInfo = _instance->locatorManager()->get(locator);
+    _locatorInfo = locator ? _instance->locatorManager()->get(locator.value()) : nullptr;
 }
 
-LocatorPrxPtr
-Ice::ObjectAdapterI::getLocator() const ICE_NOEXCEPT
+optional<LocatorPrx>
+Ice::ObjectAdapterI::getLocator() const noexcept
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-
-    if(!_locatorInfo)
-    {
-        return 0;
-    }
-    else
-    {
-        return _locatorInfo->getLocator();
-    }
+    lock_guard lock(_mutex);
+    return _locatorInfo ? optional<LocatorPrx>(_locatorInfo->getLocator()) : nullopt;
 }
 
 EndpointSeq
-Ice::ObjectAdapterI::getEndpoints() const ICE_NOEXCEPT
+Ice::ObjectAdapterI::getEndpoints() const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     EndpointSeq endpoints;
-    transform(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(),
-            back_inserter(endpoints),
-#ifdef ICE_CPP11_COMPILER
-            [](const IncomingConnectionFactoryPtr& factory)
-            {
-                return factory->endpoint();
-            });
-#else
-            Ice::constMemFun(&IncomingConnectionFactory::endpoint));
-#endif
+    transform(
+        _incomingConnectionFactories.begin(),
+        _incomingConnectionFactories.end(),
+        back_inserter(endpoints),
+        [](const IncomingConnectionFactoryPtr& factory) { return factory->endpoint(); });
     return endpoints;
 }
 
-void
-Ice::ObjectAdapterI::refreshPublishedEndpoints()
-{
-    LocatorInfoPtr locatorInfo;
-    vector<EndpointIPtr> oldPublishedEndpoints;
-
-    {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-        checkForDeactivation();
-
-        oldPublishedEndpoints = _publishedEndpoints;
-        _publishedEndpoints = computePublishedEndpoints();
-
-        locatorInfo = _locatorInfo;
-    }
-
-    try
-    {
-        Ice::Identity dummy;
-        dummy.name = "dummy";
-        updateLocatorRegistry(locatorInfo, createDirectProxy(dummy));
-    }
-    catch(const Ice::LocalException&)
-    {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-
-        //
-        // Restore the old published endpoints.
-        //
-        _publishedEndpoints = oldPublishedEndpoints;
-        throw;
-    }
-}
-
 EndpointSeq
-Ice::ObjectAdapterI::getPublishedEndpoints() const ICE_NOEXCEPT
+Ice::ObjectAdapterI::getPublishedEndpoints() const
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-    return EndpointSeq(_publishedEndpoints.begin(), _publishedEndpoints.end());
+    lock_guard lock(_mutex);
+    return {_publishedEndpoints.begin(), _publishedEndpoints.end()};
 }
 
 void
-Ice::ObjectAdapterI::setPublishedEndpoints(const EndpointSeq& newEndpoints)
+Ice::ObjectAdapterI::setPublishedEndpoints(EndpointSeq newEndpoints)
 {
     LocatorInfoPtr locatorInfo;
     vector<EndpointIPtr> oldPublishedEndpoints;
+
+    if (newEndpoints.empty())
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        throw std::invalid_argument("the newEndpoints argument must contain at least one endpoint");
+    }
+
+    {
+        lock_guard lock(_mutex);
         checkForDeactivation();
 
-        if(_routerInfo)
+        if (_routerInfo)
         {
-            const string s("can't set published endpoints on object adapter associated with a router");
-    #ifdef ICE_CPP11_MAPPING
-            throw invalid_argument(s);
-    #else
-            throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, s);
-    #endif
+            throw invalid_argument("cannot set published endpoints on an object adapter associated with a router");
         }
 
         oldPublishedEndpoints = _publishedEndpoints;
@@ -721,11 +645,11 @@ Ice::ObjectAdapterI::setPublishedEndpoints(const EndpointSeq& newEndpoints)
     {
         Ice::Identity dummy;
         dummy.name = "dummy";
-        updateLocatorRegistry(locatorInfo, createDirectProxy(dummy));
+        updateLocatorRegistry(locatorInfo, createDirectProxy(std::move(dummy)));
     }
-    catch(const Ice::LocalException&)
+    catch (const Ice::LocalException&)
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
         //
         // Restore the old published endpoints.
@@ -735,28 +659,15 @@ Ice::ObjectAdapterI::setPublishedEndpoints(const EndpointSeq& newEndpoints)
     }
 }
 
-#ifdef ICE_SWIFT
-dispatch_queue_t
-Ice::ObjectAdapterI::getDispatchQueue() const
-{
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-
-    checkForDeactivation();
-
-    return getThreadPool()->getDispatchQueue();
-}
-#endif
-
 bool
-Ice::ObjectAdapterI::isLocal(const ObjectPrxPtr& proxy) const
+Ice::ObjectAdapterI::isLocal(const ReferencePtr& ref) const
 {
     //
     // NOTE: it's important that isLocal() doesn't perform any blocking operations as
     // it can be called for AMI invocations if the proxy has no delegate set yet.
     //
 
-    ReferencePtr ref = proxy->_getReference();
-    if(ref->isWellKnown())
+    if (ref->isWellKnown())
     {
         //
         // Check the active servant map to see if the well-known
@@ -764,7 +675,7 @@ Ice::ObjectAdapterI::isLocal(const ObjectPrxPtr& proxy) const
         //
         return _servantManager->hasServant(ref->getIdentity());
     }
-    else if(ref->isIndirect())
+    else if (ref->isIndirect())
     {
         //
         // Proxy is local if the reference adapter id matches this
@@ -774,32 +685,22 @@ Ice::ObjectAdapterI::isLocal(const ObjectPrxPtr& proxy) const
     }
     else
     {
-        vector<EndpointIPtr> endpoints = ref->getEndpoints();
-
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-        checkForDeactivation();
+        lock_guard lock(_mutex);
+        checkForDestruction();
 
-        //
-        // Proxies which have at least one endpoint in common with the
-        // endpoints used by this object adapter are considered local.
-        //
-        for(vector<EndpointIPtr>::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
+        // Proxies which have at least one endpoint in common with the published endpoints are considered local.
+        // This check doesn't take datagram endpoints into account; this effectively disables colloc optimization
+        // for UDP.
+        for (const auto& endpoint : ref->getEndpoints())
         {
-            for(vector<IncomingConnectionFactoryPtr>::const_iterator q = _incomingConnectionFactories.begin();
-                q != _incomingConnectionFactories.end(); ++q)
-            {
-                if((*q)->isLocal(*p))
-                {
-                    return true;
-                }
-            }
-
-            for(vector<EndpointIPtr>::const_iterator r = _publishedEndpoints.begin();
-                r != _publishedEndpoints.end(); ++r)
+            if (!endpoint->datagram())
             {
-                if((*p)->equivalent(*r))
+                for (const auto& publishedEndpoint : _publishedEndpoints)
                 {
-                    return true;
+                    if (endpoint->equivalent(publishedEndpoint))
+                    {
+                        return true;
+                    }
                 }
             }
         }
@@ -813,13 +714,13 @@ Ice::ObjectAdapterI::flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPt
 {
     vector<IncomingConnectionFactoryPtr> f;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
         f = _incomingConnectionFactories;
     }
 
-    for(vector<IncomingConnectionFactoryPtr>::const_iterator p = f.begin(); p != f.end(); ++p)
+    for (const auto& p : f)
     {
-        (*p)->flushAsyncBatchRequests(outAsync, compress);
+        p->flushAsyncBatchRequests(outAsync, compress);
     }
 }
 
@@ -828,18 +729,13 @@ Ice::ObjectAdapterI::updateConnectionObservers()
 {
     vector<IncomingConnectionFactoryPtr> f;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
         f = _incomingConnectionFactories;
     }
-#ifdef ICE_CPP11_COMPILER
-    for_each(f.begin(), f.end(),
-        [](const IncomingConnectionFactoryPtr& factory)
-        {
-            factory->updateConnectionObservers();
-        });
-#else
-    for_each(f.begin(), f.end(), Ice::voidMemFun(&IncomingConnectionFactory::updateConnectionObservers));
-#endif
+    for_each(
+        f.begin(),
+        f.end(),
+        [](const IncomingConnectionFactoryPtr& factory) { factory->updateConnectionObservers(); });
 }
 
 void
@@ -847,10 +743,10 @@ Ice::ObjectAdapterI::updateThreadObservers()
 {
     ThreadPoolPtr threadPool;
     {
-        IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
         threadPool = _threadPool;
     }
-    if(threadPool)
+    if (threadPool)
     {
         threadPool->updateObservers();
     }
@@ -859,9 +755,9 @@ Ice::ObjectAdapterI::updateThreadObservers()
 void
 Ice::ObjectAdapterI::incDirectCount()
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    checkForDeactivation();
+    checkForDestruction();
 
     assert(_directCount >= 0);
     ++_directCount;
@@ -870,16 +766,16 @@ Ice::ObjectAdapterI::incDirectCount()
 void
 Ice::ObjectAdapterI::decDirectCount()
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     // Not check for deactivation here!
 
     assert(_instance); // Must not be called after destroy().
 
     assert(_directCount > 0);
-    if(--_directCount == 0)
+    if (--_directCount == 0)
     {
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 }
 
@@ -894,7 +790,7 @@ Ice::ObjectAdapterI::getThreadPool() const
 
     assert(_instance); // Must not be called after destroy().
 
-    if(_threadPool)
+    if (_threadPool)
     {
         return _threadPool;
     }
@@ -904,30 +800,12 @@ Ice::ObjectAdapterI::getThreadPool() const
     }
 }
 
-ServantManagerPtr
-Ice::ObjectAdapterI::getServantManager() const
-{
-    //
-    // No mutex lock necessary, _servantManager is immutable.
-    //
-    return _servantManager;
-}
-
-IceInternal::ACMConfig
-Ice::ObjectAdapterI::getACM() const
-{
-    // Not check for deactivation here!
-
-    assert(_instance); // Must not be called after destroy().
-    return _acm;
-}
-
 void
 Ice::ObjectAdapterI::setAdapterOnConnection(const Ice::ConnectionIPtr& connection)
 {
-    IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
-    checkForDeactivation();
-    connection->setAdapterAndServantManager(ICE_SHARED_FROM_THIS, _servantManager);
+    lock_guard lock(_mutex);
+    checkForDestruction();
+    connection->setAdapterFromAdapter(shared_from_this());
 }
 
 //
@@ -935,56 +813,84 @@ Ice::ObjectAdapterI::setAdapterOnConnection(const Ice::ConnectionIPtr& connectio
 // function because when it was part of the constructor C++Builder 2010 apps would
 // crash if an exception was thrown from any calls within the constructor.
 //
-Ice::ObjectAdapterI::ObjectAdapterI(const InstancePtr& instance, const CommunicatorPtr& communicator,
-                                    const ObjectAdapterFactoryPtr& objectAdapterFactory, const string& name,
-                                    /*const RouterPrxPtr& router,*/ bool noConfig) :
-    _state(StateUninitialized),
-    _instance(instance),
-    _communicator(communicator),
-    _objectAdapterFactory(objectAdapterFactory),
-    _servantManager(new ServantManager(instance, name)),
-    _name(name),
-    _directCount(0),
-    _noConfig(noConfig),
-    _messageSizeMax(0)
+Ice::ObjectAdapterI::ObjectAdapterI(
+    InstancePtr instance,
+    CommunicatorPtr communicator,
+    ObjectAdapterFactoryPtr objectAdapterFactory,
+    string name,
+    bool noConfig,
+    optional<SSL::ServerAuthenticationOptions> serverAuthenticationOptions)
+    : _instance(std::move(instance)),
+      _communicator(std::move(communicator)),
+      _objectAdapterFactory(std::move(objectAdapterFactory)),
+      _servantManager(make_shared<ServantManager>(_instance, name)),
+      _name(std::move(name)),
+      _noConfig(noConfig),
+      _serverAuthenticationOptions(std::move(serverAuthenticationOptions))
 {
+#if defined(ICE_USE_SCHANNEL)
+    if (_serverAuthenticationOptions && _serverAuthenticationOptions->trustedRootCertificates)
+    {
+        CertDuplicateStore(_serverAuthenticationOptions->trustedRootCertificates);
+    }
+#elif defined(ICE_USE_SECURE_TRANSPORT)
+    if (_serverAuthenticationOptions && _serverAuthenticationOptions->trustedRootCertificates)
+    {
+        CFRetain(_serverAuthenticationOptions->trustedRootCertificates);
+    }
+#endif
 }
 
 void
-Ice::ObjectAdapterI::initialize(const RouterPrxPtr& router)
+Ice::ObjectAdapterI::initialize(optional<RouterPrx> router)
 {
-    if(_noConfig)
+    // shared_from_this() is available now and is called by `use`.
+
+    const LoggerPtr logger = _instance->initializationData().logger;
+    if (logger)
     {
-        _reference = _instance->referenceFactory()->create("dummy -t", "");
-        const_cast<ACMConfig&>(_acm) = _instance->serverACM();
-        return;
+        int warningLevel = _instance->initializationData().properties->getIcePropertyAsInt("Ice.Warn.Dispatch");
+        if (_instance->traceLevels()->dispatch > 0 || warningLevel > 0)
+        {
+            use(
+                [logger,
+                 warningLevel,
+                 traceLevel = _instance->traceLevels()->dispatch,
+                 traceCat = _instance->traceLevels()->dispatchCat,
+                 toStringMode = _instance->toStringMode()](ObjectPtr next)
+                {
+                    return make_shared<LoggerMiddleware>(
+                        std::move(next),
+                        logger,
+                        traceLevel,
+                        traceCat,
+                        warningLevel,
+                        toStringMode);
+                });
+        }
     }
 
-    PropertiesPtr properties = _instance->initializationData().properties;
-    StringSeq unknownProps;
-    bool noProps = filterProperties(unknownProps);
+    const Instrumentation::CommunicatorObserverPtr observer = _instance->initializationData().observer;
+    if (observer)
+    {
+        use([observer](ObjectPtr next) { return make_shared<ObserverMiddleware>(std::move(next), observer); });
+    }
 
-    //
-    // Warn about unknown object adapter properties.
-    //
-    if(unknownProps.size() != 0 && properties->getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
+    if (_noConfig)
     {
-        Warning out(_instance->initializationData().logger);
-        out << "found unknown properties for object adapter `" << _name << "':";
-        for(unsigned int i = 0; i < unknownProps.size(); ++i)
-        {
-            out << "\n    " << unknownProps[i];
-        }
+        _reference = _instance->referenceFactory()->create("dummy -t", "");
+        return;
     }
 
+    PropertiesPtr properties = _instance->initializationData().properties;
+
     try
     {
-        //
-        // Make sure named adapter has some configuration
-        //
-        if(router == 0 && noProps)
+        validatePropertiesWithPrefix(_name, properties, &PropertyNames::ObjectAdapterProps);
+
+        if (!router && properties->getPropertiesForPrefix(_name + ".").size() == 0)
         {
-            throw InitializationException(__FILE__, __LINE__, "object adapter `" + _name + "' requires configuration");
+            throw InitializationException(__FILE__, __LINE__, "object adapter '" + _name + "' requires configuration");
         }
 
         const_cast<string&>(_id) = properties->getProperty(_name + ".AdapterId");
@@ -999,66 +905,82 @@ Ice::ObjectAdapterI::initialize(const RouterPrxPtr& router)
         {
             _reference = _instance->referenceFactory()->create("dummy " + proxyOptions, "");
         }
-        catch(const ProxyParseException&)
+        catch (const ParseException&)
         {
-            throw InitializationException(__FILE__, __LINE__, "invalid proxy options `" + proxyOptions +
-                                          "' for object adapter `" + _name + "'");
+            throw InitializationException(
+                __FILE__,
+                __LINE__,
+                "invalid proxy options '" + proxyOptions + "' for object adapter '" + _name + "'");
         }
 
-        const_cast<ACMConfig&>(_acm) =
-            ACMConfig(properties, _communicator->getLogger(), _name + ".ACM", _instance->serverACM());
-
         {
             const int defaultMessageSizeMax = static_cast<int>(_instance->messageSizeMax() / 1024);
-            Int num = properties->getPropertyAsIntWithDefault(_name + ".MessageSizeMax", defaultMessageSizeMax);
-            if(num < 1 || static_cast<size_t>(num) > static_cast<size_t>(0x7fffffff / 1024))
+            int32_t messageSizeMax =
+                properties->getPropertyAsIntWithDefault(_name + ".MessageSizeMax", defaultMessageSizeMax);
+            // The maximum size of an Ice protocol message in bytes. This is limited to 0x7fffffff, which corresponds to
+            // the maximum value of a 32-bit signed integer (int32_t).
+            const int32_t messageSizeMaxUpperLimit = numeric_limits<int32_t>::max();
+            if (messageSizeMax > messageSizeMaxUpperLimit / 1024)
             {
-                const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(0x7fffffff);
+                ostringstream os;
+                os << _name << ".MessageSizeMax '" << messageSizeMax
+                   << "' is too large, it must be less than or equal to '" << (messageSizeMaxUpperLimit / 1024)
+                   << "' KiB";
+                throw InitializationException{__FILE__, __LINE__, os.str()};
+            }
+            else if (messageSizeMax < 1)
+            {
+                const_cast<int32_t&>(_messageSizeMax) = 0x7fffffff;
             }
             else
             {
-                const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(num) * 1024;
+                const_cast<int32_t&>(_messageSizeMax) = messageSizeMax * 1024;
             }
         }
 
-        int threadPoolSize = properties->getPropertyAsInt(_name + ".ThreadPool.Size");
-        int threadPoolSizeMax = properties->getPropertyAsInt(_name + ".ThreadPool.SizeMax");
-        bool hasPriority = properties->getProperty(_name + ".ThreadPool.ThreadPriority") != "";
-
-        //
-        // Create the per-adapter thread pool, if necessary. This is done before the creation of the incoming
-        // connection factory as the thread pool is needed during creation for the call to incFdsInUse.
-        //
-        if(threadPoolSize > 0 || threadPoolSizeMax > 0 || hasPriority)
+        // If the user configured any of the ObjectAdapter.ThreadPool properties, create a per-adapter thread pool.
+        // Otherwise the OA will use the default server thread pool.
+        // This is done before the creation of the incoming connection factory as the thread pool is needed during
+        // creation for the call to incFdsInUse.
+        if (properties->getPropertiesForPrefix(_name + ".ThreadPool.").size() > 0)
         {
-            _threadPool = new ThreadPool(_instance, _name + ".ThreadPool", 0);
+            _threadPool = ThreadPool::create(_instance, _name + ".ThreadPool", 0);
         }
 
-        if(!router)
+        if (!router)
         {
-            const_cast<RouterPrxPtr&>(router) = ICE_UNCHECKED_CAST(RouterPrx,
-                                _instance->proxyFactory()->propertyToProxy(_name + ".Router"));
+            router = _communicator->propertyToProxy<RouterPrx>(_name + ".Router");
         }
-        if(router)
+        if (router)
         {
-            _routerInfo = _instance->routerManager()->get(router);
+            _routerInfo = _instance->routerManager()->get(router.value());
             assert(_routerInfo);
 
+            if (!properties->getProperty(_name + ".Endpoints").empty())
+            {
+                throw InitializationException{
+                    __FILE__,
+                    __LINE__,
+                    "an object adapter with a router cannot accept incoming connections"};
+            }
+
             //
             // Make sure this router is not already registered with another adapter.
             //
-            if(_routerInfo->getAdapter())
+            if (_routerInfo->getAdapter())
             {
-                throw AlreadyRegisteredException(__FILE__, __LINE__,
-                                                 "object adapter with router",
-                                                 _communicator->identityToString(router->ice_getIdentity()));
+                throw AlreadyRegisteredException(
+                    __FILE__,
+                    __LINE__,
+                    "object adapter with router",
+                    _communicator->identityToString(router->ice_getIdentity()));
             }
 
             //
             // Associate this object adapter with the router. This way, new outgoing connections
             // to the router's client proxy will use this object adapter for callbacks.
             //
-            _routerInfo->setAdapter(ICE_SHARED_FROM_THIS);
+            _routerInfo->setAdapter(shared_from_this());
 
             //
             // Also modify all existing outgoing connections to the router's client proxy to use
@@ -1074,28 +996,22 @@ Ice::ObjectAdapterI::initialize(const RouterPrxPtr& router)
             // fill in the real port number.
             //
             vector<EndpointIPtr> endpoints = parseEndpoints(properties->getProperty(_name + ".Endpoints"), true);
-            for(vector<EndpointIPtr>::iterator p = endpoints.begin(); p != endpoints.end(); ++p)
+            for (const auto& endpoint : endpoints)
             {
-                EndpointIPtr publishedEndpoint;
-                vector<EndpointIPtr> expanded = (*p)->expandHost(publishedEndpoint);
-                for(vector<EndpointIPtr>::iterator q = expanded.begin(); q != expanded.end(); ++q)
+                for (const auto& expanded : endpoint->expandHost())
                 {
-                    IncomingConnectionFactoryPtr factory = ICE_MAKE_SHARED(IncomingConnectionFactory,
-                                                                           _instance,
-                                                                           *q,
-                                                                           publishedEndpoint,
-                                                                           ICE_SHARED_FROM_THIS);
+                    auto factory = make_shared<IncomingConnectionFactory>(_instance, expanded, shared_from_this());
                     factory->initialize();
                     _incomingConnectionFactories.push_back(factory);
                 }
             }
-            if(endpoints.empty())
+            if (endpoints.empty())
             {
                 TraceLevelsPtr tl = _instance->traceLevels();
-                if(tl->network >= 2)
+                if (tl->network >= 2)
                 {
                     Trace out(_instance->initializationData().logger, tl->networkCat);
-                    out << "created adapter `" << _name << "' without endpoints";
+                    out << "created adapter '" << _name << "' without endpoints";
                 }
             }
         }
@@ -1105,16 +1021,16 @@ Ice::ObjectAdapterI::initialize(const RouterPrxPtr& router)
         //
         _publishedEndpoints = computePublishedEndpoints();
 
-        if(!properties->getProperty(_name + ".Locator").empty())
+        if (!properties->getProperty(_name + ".Locator").empty())
         {
-            setLocator(ICE_UNCHECKED_CAST(LocatorPrx, _instance->proxyFactory()->propertyToProxy(_name + ".Locator")));
+            setLocator(_communicator->propertyToProxy<LocatorPrx>(_name + ".Locator"));
         }
         else
         {
             setLocator(_instance->referenceFactory()->getDefaultLocator());
         }
     }
-    catch(...)
+    catch (...)
     {
         destroy();
         throw;
@@ -1123,101 +1039,115 @@ Ice::ObjectAdapterI::initialize(const RouterPrxPtr& router)
 
 Ice::ObjectAdapterI::~ObjectAdapterI()
 {
-    if(_state < StateDeactivated)
+#if defined(ICE_USE_SCHANNEL)
+    if (_serverAuthenticationOptions && _serverAuthenticationOptions->trustedRootCertificates)
+    {
+        CertCloseStore(_serverAuthenticationOptions->trustedRootCertificates, 0);
+    }
+#elif defined(ICE_USE_SECURE_TRANSPORT)
+    if (_serverAuthenticationOptions && _serverAuthenticationOptions->trustedRootCertificates)
+    {
+        CFRelease(_serverAuthenticationOptions->trustedRootCertificates);
+    }
+#endif
+    if (_state < StateDeactivated)
     {
         Warning out(_instance->initializationData().logger);
-        out << "object adapter `" << getName() << "' has not been deactivated";
+        out << "object adapter '" << getName() << "' has not been deactivated";
     }
-    else if(_state != StateDestroyed)
+    else if (_state != StateDestroyed)
     {
         Warning out(_instance->initializationData().logger);
-        out << "object adapter `" << getName() << "' has not been destroyed";
+        out << "object adapter '" << getName() << "' has not been destroyed";
     }
     else
     {
-        //assert(!_servantManager); // We don't clear this reference, it needs to be immutable.
+        // assert(!_servantManager); // We don't clear this reference, it needs to be immutable.
         assert(!_threadPool);
         assert(_incomingConnectionFactories.empty());
         assert(_directCount == 0);
     }
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::newProxy(const Identity& ident, const string& facet) const
+ObjectPrx
+Ice::ObjectAdapterI::newProxy(Identity ident, string facet) const
 {
-    if(_id.empty())
+    if (_id.empty())
     {
-        return newDirectProxy(ident, facet);
+        return newDirectProxy(std::move(ident), std::move(facet));
     }
-    else if(_replicaGroupId.empty())
+    else if (_replicaGroupId.empty())
     {
-        return newIndirectProxy(ident, facet, _id);
+        return newIndirectProxy(std::move(ident), std::move(facet), _id);
     }
     else
     {
-        return newIndirectProxy(ident, facet, _replicaGroupId);
+        return newIndirectProxy(std::move(ident), std::move(facet), _replicaGroupId);
     }
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::newDirectProxy(const Identity& ident, const string& facet) const
+ObjectPrx
+Ice::ObjectAdapterI::newDirectProxy(Identity ident, string facet) const
 {
-    //
-    // Create a reference and return a proxy for this reference.
-    //
-    ReferencePtr ref = _instance->referenceFactory()->create(ident, facet, _reference, _publishedEndpoints);
-    return _instance->proxyFactory()->referenceToProxy(ref);
+    return ObjectPrx::_fromReference(
+        _instance->referenceFactory()->create(std::move(ident), std::move(facet), _reference, _publishedEndpoints));
 }
 
-ObjectPrxPtr
-Ice::ObjectAdapterI::newIndirectProxy(const Identity& ident, const string& facet, const string& id) const
+ObjectPrx
+Ice::ObjectAdapterI::newIndirectProxy(Identity ident, string facet, string id) const
 {
     //
     // Create an indirect reference with the given adapter id.
     //
-    ReferencePtr ref = _instance->referenceFactory()->create(ident, facet, _reference, id);
-
-    //
-    // Return a proxy for the reference.
-    //
-    return _instance->proxyFactory()->referenceToProxy(ref);
+    return ObjectPrx::_fromReference(
+        _instance->referenceFactory()->create(std::move(ident), std::move(facet), _reference, std::move(id)));
 }
 
 void
 Ice::ObjectAdapterI::checkForDeactivation() const
 {
-    if(_state >= StateDeactivating)
+    checkForDestruction();
+    if (_state >= StateDeactivating)
     {
-        throw ObjectAdapterDeactivatedException(__FILE__, __LINE__, getName());
+        throw ObjectAdapterDeactivatedException{__FILE__, __LINE__, getName()};
+    }
+}
+
+void
+Ice::ObjectAdapterI::checkForDestruction() const
+{
+    if (_state >= StateDestroying)
+    {
+        throw ObjectAdapterDestroyedException{__FILE__, __LINE__, getName()};
     }
 }
 
 vector<EndpointIPtr>
-Ice::ObjectAdapterI::parseEndpoints(const string& endpts, bool oaEndpoints) const
+Ice::ObjectAdapterI::parseEndpoints(string_view endpts, bool oaEndpoints) const
 {
     string::size_type beg;
     string::size_type end = 0;
 
     vector<EndpointIPtr> endpoints;
-    while(end < endpts.length())
+    while (end < endpts.length())
     {
         const string delim = " \t\n\r";
 
         beg = endpts.find_first_not_of(delim, end);
-        if(beg == string::npos)
+        if (beg == string::npos)
         {
-            if(!endpoints.empty())
+            if (!endpoints.empty())
             {
-                throw EndpointParseException(__FILE__, __LINE__, "invalid empty object adapter endpoint");
+                throw ParseException(__FILE__, __LINE__, "invalid empty object adapter endpoint");
             }
             break;
         }
 
         end = beg;
-        while(true)
+        while (true)
         {
             end = endpts.find(':', end);
-            if(end == string::npos)
+            if (end == string::npos)
             {
                 end = endpts.length();
                 break;
@@ -1226,21 +1156,21 @@ Ice::ObjectAdapterI::parseEndpoints(const string& endpts, bool oaEndpoints) cons
             {
                 bool quoted = false;
                 string::size_type quote = beg;
-                while(true)
+                while (true)
                 {
                     quote = endpts.find('\"', quote);
-                    if(quote == string::npos || end < quote)
+                    if (quote == string::npos || end < quote)
                     {
                         break;
                     }
                     else
                     {
                         quote = endpts.find('\"', ++quote);
-                        if(quote == string::npos)
+                        if (quote == string::npos)
                         {
                             break;
                         }
-                        else if(end < quote)
+                        else if (end < quote)
                         {
                             quoted = true;
                             break;
@@ -1248,7 +1178,7 @@ Ice::ObjectAdapterI::parseEndpoints(const string& endpts, bool oaEndpoints) cons
                         ++quote;
                     }
                 }
-                if(!quoted)
+                if (!quoted)
                 {
                     break;
                 }
@@ -1256,16 +1186,16 @@ Ice::ObjectAdapterI::parseEndpoints(const string& endpts, bool oaEndpoints) cons
             }
         }
 
-        if(end == beg)
+        if (end == beg)
         {
-            throw EndpointParseException(__FILE__, __LINE__, "invalid empty object adapter endpoint");
+            throw ParseException(__FILE__, __LINE__, "invalid empty object adapter endpoint");
         }
 
-        string s = endpts.substr(beg, end - beg);
+        string_view s = endpts.substr(beg, end - beg);
         EndpointIPtr endp = _instance->endpointFactoryManager()->create(s, oaEndpoints);
-        if(endp == 0)
+        if (endp == nullptr)
         {
-            throw EndpointParseException(__FILE__, __LINE__, "invalid object adapter endpoint `" + s + "'");
+            throw ParseException(__FILE__, __LINE__, "invalid object adapter endpoint '" + string{s} + "'");
         }
         endpoints.push_back(endp);
 
@@ -1279,61 +1209,74 @@ std::vector<EndpointIPtr>
 ObjectAdapterI::computePublishedEndpoints()
 {
     vector<EndpointIPtr> endpoints;
-    if(_routerInfo)
+    if (_routerInfo)
     {
-        //
         // Get the router's server proxy endpoints and use them as the published endpoints.
-        //
-        vector<EndpointIPtr> endps = _routerInfo->getServerEndpoints();
-        for(vector<EndpointIPtr>::const_iterator p = endps.begin(); p != endps.end(); ++p)
-        {
-            if(::find(endpoints.begin(), endpoints.end(), *p) == endpoints.end())
-            {
-                endpoints.push_back(*p);
-            }
-        }
+        endpoints = _routerInfo->getServerEndpoints();
     }
     else
     {
-        //
-        // Parse published endpoints. If set, these are used in proxies
-        // instead of the connection factory endpoints.
-        //
-        string endpts = _communicator->getProperties()->getProperty(_name + ".PublishedEndpoints");
-        endpoints = parseEndpoints(endpts, false);
-        if(endpoints.empty())
+        // Parse published endpoints. If set, these are used in proxies instead of the connection factory endpoints.
+        endpoints = parseEndpoints(_communicator->getProperties()->getProperty(_name + ".PublishedEndpoints"), false);
+        if (endpoints.empty())
         {
-            //
-            // If the PublishedEndpoints property isn't set, we compute the published endpoints
-            // from the OA endpoints, expanding any endpoints that may be listening on INADDR_ANY
-            // to include actual addresses in the published endpoints.
-            //
-            for(unsigned int i = 0; i < _incomingConnectionFactories.size(); ++i)
+            // If the PublishedEndpoints property isn't set, we compute the published endpoints from the factory
+            // endpoints.
+            for (const auto& factory : _incomingConnectionFactories)
+            {
+                endpoints.push_back(factory->endpoint());
+            }
+
+            // Remove all loopback/multicast endpoints
+            vector<EndpointIPtr> endpointsNoLoopback;
+            copy_if(
+                endpoints.begin(),
+                endpoints.end(),
+                back_inserter(endpointsNoLoopback),
+                [](const EndpointIPtr& endpoint) { return !endpoint->isLoopbackOrMulticast(); });
+
+            // Retrieve published host
+            string publishedHost = _communicator->getProperties()->getProperty(_name + ".PublishedHost");
+
+            if (!endpointsNoLoopback.empty())
             {
-                vector<EndpointIPtr> endps = _incomingConnectionFactories[i]->endpoint()->expandIfWildcard();
-                for(vector<EndpointIPtr>::const_iterator p = endps.begin(); p != endps.end(); ++p)
+                endpoints = std::move(endpointsNoLoopback);
+
+                // For non-loopback/multicast endpoints, we use the fully qualified name of the local host as default
+                // for publishedHost.
+                if (publishedHost.empty())
                 {
-                    //
-                    // Check for duplicate endpoints, this might occur if an endpoint with a DNS name
-                    // expands to multiple addresses. In this case, multiple incoming connection
-                    // factories can point to the same published endpoint.
-                    //
-                    if(::find(endpoints.begin(), endpoints.end(), *p) == endpoints.end())
-                    {
-                        endpoints.push_back(*p);
-                    }
+                    publishedHost = getHostName(); // fully qualified name of local host
                 }
             }
+            // else keep endpoints as-is; they are all loopback or multicast
+
+            vector<EndpointIPtr> newEndpoints;
+
+            // Replace the host in all endpoints by publishedHost (when applicable), clear local options and remove
+            // duplicates.
+            for (const auto& endpoint : endpoints)
+            {
+                EndpointIPtr newEndpoint = endpoint->toPublishedEndpoint(publishedHost);
+                if (none_of(
+                        newEndpoints.begin(),
+                        newEndpoints.end(),
+                        [&newEndpoint](const EndpointIPtr& p) { return *newEndpoint == *p; }))
+                {
+                    newEndpoints.push_back(newEndpoint);
+                }
+            }
+            endpoints = std::move(newEndpoints);
         }
     }
 
-    if(_instance->traceLevels()->network >= 1 && !endpoints.empty())
+    if (_instance->traceLevels()->network >= 1 && !endpoints.empty())
     {
         Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
-        out << "published endpoints for object adapter `" << getName() << "':\n";
-        for(unsigned int i = 0; i < endpoints.size(); ++i)
+        out << "published endpoints for object adapter '" << getName() << "':\n";
+        for (size_t i = 0; i < endpoints.size(); ++i)
         {
-            if(i > 0)
+            if (i > 0)
             {
                 out << ":";
             }
@@ -1345,22 +1288,22 @@ ObjectAdapterI::computePublishedEndpoints()
 }
 
 void
-ObjectAdapterI::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locatorInfo, const Ice::ObjectPrxPtr& proxy)
+ObjectAdapterI::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locatorInfo, const optional<ObjectPrx>& proxy)
 {
-    if(_id.empty() || !locatorInfo)
+    if (_id.empty() || !locatorInfo)
     {
         return; // Nothing to update.
     }
 
-    LocatorRegistryPrxPtr locatorRegistry = locatorInfo->getLocatorRegistry();
-    if(!locatorRegistry)
+    optional<LocatorRegistryPrx> locatorRegistry = locatorInfo->getLocatorRegistry();
+    if (!locatorRegistry)
     {
         return;
     }
 
     try
     {
-        if(_replicaGroupId.empty())
+        if (_replicaGroupId.empty())
         {
             locatorRegistry->setAdapterDirectProxy(_id, proxy);
         }
@@ -1369,162 +1312,72 @@ ObjectAdapterI::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locator
             locatorRegistry->setReplicatedAdapterDirectProxy(_id, _replicaGroupId, proxy);
         }
     }
-    catch(const AdapterNotFoundException&)
+    catch (const AdapterNotFoundException&)
     {
-        if(_instance->traceLevels()->location >= 1)
+        if (_instance->traceLevels()->location >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-            out << "couldn't update object adapter `" + _id + "' endpoints with the locator registry:\n";
+            out << "couldn't update object adapter '" + _id + "' endpoints with the locator registry:\n";
             out << "the object adapter is not known to the locator registry";
         }
 
         throw NotRegisteredException(__FILE__, __LINE__, "object adapter", _id);
     }
-    catch(const InvalidReplicaGroupIdException&)
+    catch (const InvalidReplicaGroupIdException&)
     {
-        if(_instance->traceLevels()->location >= 1)
+        if (_instance->traceLevels()->location >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-            out << "couldn't update object adapter `" + _id + "' endpoints with the locator registry:\n";
-            out << "the replica group `" << _replicaGroupId << "' is not known to the locator registry";
+            out << "couldn't update object adapter '" + _id + "' endpoints with the locator registry:\n";
+            out << "the replica group '" << _replicaGroupId << "' is not known to the locator registry";
         }
 
         throw NotRegisteredException(__FILE__, __LINE__, "replica group", _replicaGroupId);
     }
-    catch(const AdapterAlreadyActiveException&)
+    catch (const AdapterAlreadyActiveException&)
     {
-        if(_instance->traceLevels()->location >= 1)
+        if (_instance->traceLevels()->location >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-            out << "couldn't update object adapter `" + _id + "' endpoints with the locator registry:\n";
+            out << "couldn't update object adapter '" + _id + "' endpoints with the locator registry:\n";
             out << "the object adapter endpoints are already set";
         }
 
         throw ObjectAdapterIdInUseException(__FILE__, __LINE__, _id);
     }
-    catch(const ObjectAdapterDeactivatedException&)
+    catch (const ObjectAdapterDeactivatedException&)
     {
         // Expected if collocated call and OA is deactivated, ignore.
     }
-    catch(const CommunicatorDestroyedException&)
+    catch (const CommunicatorDestroyedException&)
     {
         // Ignore.
     }
-    catch(const LocalException& ex)
+    catch (const LocalException& ex)
     {
-        if(_instance->traceLevels()->location >= 1)
+        if (_instance->traceLevels()->location >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-            out << "couldn't update object adapter `" + _id + "' endpoints with the locator registry:\n" << ex;
+            out << "couldn't update object adapter '" + _id + "' endpoints with the locator registry:\n" << ex;
         }
         throw; // TODO: Shall we raise a special exception instead of a non obvious local exception?
     }
 
-    if(_instance->traceLevels()->location >= 1)
+    if (_instance->traceLevels()->location >= 1)
     {
         Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-        out << "updated object adapter `" + _id + "' endpoints with the locator registry\n";
+        out << "updated object adapter '" + _id + "' endpoints with the locator registry\n";
         out << "endpoints = ";
-        if(proxy)
+        if (proxy)
         {
             EndpointSeq endpts = proxy ? proxy->ice_getEndpoints() : EndpointSeq();
             ostringstream o;
-#ifdef ICE_CPP11_COMPILER
-            transform(endpts.begin(), endpts.end(), ostream_iterator<string>(o, endpts.size() > 1 ? ":" : ""),
-                      [](const EndpointPtr& endpoint)
-                      {
-                          return endpoint->toString();
-                      });
-#else
-            transform(endpts.begin(), endpts.end(), ostream_iterator<string>(o, endpts.size() > 1 ? ":" : ""),
-                      Ice::constMemFun(&Endpoint::toString));
-#endif
+            transform(
+                endpts.begin(),
+                endpts.end(),
+                ostream_iterator<string>(o, endpts.size() > 1 ? ":" : ""),
+                [](const EndpointPtr& endpoint) { return endpoint->toString(); });
             out << o.str();
         }
     }
 }
-
-bool
-Ice::ObjectAdapterI::filterProperties(StringSeq& unknownProps)
-{
-    static const string suffixes[] =
-    {
-        "ACM",
-        "ACM.Close",
-        "ACM.Heartbeat",
-        "ACM.Timeout",
-        "AdapterId",
-        "Endpoints",
-        "Locator",
-        "Locator.EncodingVersion",
-        "Locator.EndpointSelection",
-        "Locator.ConnectionCached",
-        "Locator.PreferSecure",
-        "Locator.CollocationOptimized",
-        "Locator.Router",
-        "MessageSizeMax",
-        "PublishedEndpoints",
-        "ReplicaGroupId",
-        "Router",
-        "Router.EncodingVersion",
-        "Router.EndpointSelection",
-        "Router.ConnectionCached",
-        "Router.PreferSecure",
-        "Router.CollocationOptimized",
-        "Router.Locator",
-        "Router.Locator.EndpointSelection",
-        "Router.Locator.ConnectionCached",
-        "Router.Locator.PreferSecure",
-        "Router.Locator.CollocationOptimized",
-        "Router.Locator.LocatorCacheTimeout",
-        "Router.Locator.InvocationTimeout",
-        "Router.LocatorCacheTimeout",
-        "Router.InvocationTimeout",
-        "ProxyOptions",
-        "ThreadPool.Size",
-        "ThreadPool.SizeMax",
-        "ThreadPool.SizeWarn",
-        "ThreadPool.StackSize",
-        "ThreadPool.Serialize",
-        "ThreadPool.ThreadPriority"
-    };
-
-    //
-    // Do not create unknown properties list if Ice prefix, ie Ice, Glacier2, etc
-    //
-    bool addUnknown = true;
-    string prefix = _name + ".";
-    for(const char** i = IceInternal::PropertyNames::clPropNames; *i != 0; ++i)
-    {
-        string icePrefix = string(*i) + ".";
-        if(prefix.find(icePrefix) == 0)
-        {
-            addUnknown = false;
-            break;
-        }
-    }
-
-    bool noProps = true;
-    PropertyDict props = _instance->initializationData().properties->getPropertiesForPrefix(prefix);
-    for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p)
-    {
-        bool valid = false;
-        for(unsigned int i = 0; i < sizeof(suffixes)/sizeof(*suffixes); ++i)
-        {
-            string prop = prefix + suffixes[i];
-            if(p->first == prop)
-            {
-                noProps = false;
-                valid = true;
-                break;
-            }
-        }
-
-        if(!valid && addUnknown)
-        {
-            unknownProps.push_back(p->first);
-        }
-    }
-
-    return noProps;
-}