zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,149 +1,87 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/Reference.h>
-#include <Ice/ReferenceFactory.h>
-#include <Ice/LocalException.h>
-#include <Ice/Instance.h>
-#include <Ice/EndpointI.h>
-#include <Ice/OpaqueEndpointI.h>
-#include <Ice/OutputStream.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/Router.h>
-#include <Ice/LocatorInfo.h>
-#include <Ice/Locator.h>
-#include <Ice/Functional.h>
-#include <Ice/ConnectionI.h>
-#include <Ice/ConnectionFactory.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/HashUtil.h>
-#include <Ice/RequestHandlerFactory.h>
-#include <Ice/ConnectionRequestHandler.h>
-#include <Ice/DefaultsAndOverrides.h>
-#include <Ice/Comparable.h>
-#include <Ice/StringUtil.h>
-
-#include <IceUtil/Random.h>
-#include <IceUtil/MutexPtrLock.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "Reference.h"
+#include "CollocatedRequestHandler.h"
+#include "ConnectRequestHandler.h"
+#include "ConnectionFactory.h"
+#include "ConnectionI.h"
+#include "DefaultsAndOverrides.h"
+#include "EndpointI.h"
+#include "FixedRequestHandler.h"
+#include "HashUtil.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Locator.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/OutputStream.h"
+#include "Ice/Router.h"
+#include "Ice/StringUtil.h"
+#include "Instance.h"
+#include "LocatorInfo.h"
+#include "ObjectAdapterFactory.h"
+#include "OpaqueEndpointI.h"
+#include "Random.h"
+#include "ReferenceFactory.h"
+#include "RouterInfo.h"
+#include "TargetCompare.h"
+#include "TraceLevels.h"
 
-#include <functional>
 #include <algorithm>
+#include <functional>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(IceInternal::Reference* p) { return p; }
-
-namespace
-{
-
-IceUtil::Mutex* hashMutex = 0;
-
-class Init
-{
-public:
-
-    Init()
-    {
-        hashMutex = new IceUtil::Mutex;
-    }
-
-    ~Init()
-    {
-        delete hashMutex;
-        hashMutex = 0;
-    }
-};
-
-Init init;
-
-}
-
 CommunicatorPtr
-IceInternal::Reference::getCommunicator() const
+IceInternal::Reference::getCommunicator() const noexcept
 {
     return _communicator;
 }
 
 ReferencePtr
-IceInternal::Reference::changeContext(const Context& newContext) const
+IceInternal::Reference::changeContext(Context newContext) const
 {
-    ReferencePtr r = _instance->referenceFactory()->copy(this);
-    r->_context = new SharedContext(newContext);
+    ReferencePtr r = clone();
+    r->_context = make_shared<SharedContext>(std::move(newContext));
     return r;
 }
 
 ReferencePtr
 IceInternal::Reference::changeMode(Mode newMode) const
 {
-    if(newMode == _mode)
-    {
-        return ReferencePtr(const_cast<Reference*>(this));
-    }
-    ReferencePtr r = _instance->referenceFactory()->copy(this);
+    ReferencePtr r = clone();
     r->_mode = newMode;
     return r;
 }
 
 ReferencePtr
-IceInternal::Reference::changeSecure(bool newSecure) const
-{
-    if(newSecure == _secure)
-    {
-        return ReferencePtr(const_cast<Reference*>(this));
-    }
-    ReferencePtr r = _instance->referenceFactory()->copy(this);
-    r->_secure = newSecure;
-    return r;
-}
-
-ReferencePtr
-IceInternal::Reference::changeIdentity(const Identity& newIdentity) const
+IceInternal::Reference::changeIdentity(Identity newIdentity) const
 {
-    if(newIdentity == _identity)
-    {
-        return ReferencePtr(const_cast<Reference*>(this));
-    }
-    ReferencePtr r = _instance->referenceFactory()->copy(this);
-    r->_identity = newIdentity;
+    ReferencePtr r = clone();
+    r->_identity = std::move(newIdentity);
     return r;
 }
 
 ReferencePtr
-IceInternal::Reference::changeFacet(const string& newFacet) const
+IceInternal::Reference::changeFacet(string newFacet) const
 {
-    if(newFacet == _facet)
-    {
-        return ReferencePtr(const_cast<Reference*>(this));
-    }
-    ReferencePtr r = _instance->referenceFactory()->copy(this);
-    r->_facet = newFacet;
+    ReferencePtr r = clone();
+    r->_facet = std::move(newFacet);
     return r;
 }
 
 ReferencePtr
-IceInternal::Reference::changeInvocationTimeout(int invocationTimeout) const
+IceInternal::Reference::changeInvocationTimeout(chrono::milliseconds invocationTimeout) const
 {
-    if(_invocationTimeout == invocationTimeout)
-    {
-        return ReferencePtr(const_cast<Reference*>(this));
-    }
-    ReferencePtr r = _instance->referenceFactory()->copy(this);
+    ReferencePtr r = clone();
     r->_invocationTimeout = invocationTimeout;
     return r;
 }
 
 ReferencePtr
-IceInternal::Reference::changeEncoding(const Ice::EncodingVersion& encoding) const
+IceInternal::Reference::changeEncoding(Ice::EncodingVersion encoding) const
 {
-    if(_encoding == encoding)
-    {
-        return ReferencePtr(const_cast<Reference*>(this));
-    }
-    ReferencePtr r = _instance->referenceFactory()->copy(this);
+    ReferencePtr r = clone();
     r->_encoding = encoding;
     return r;
 }
@@ -151,45 +89,33 @@ IceInternal::Reference::changeEncoding(const Ice::EncodingVersion& encoding) con
 ReferencePtr
 IceInternal::Reference::changeCompress(bool newCompress) const
 {
-    if(_overrideCompress && newCompress == _compress)
-    {
-        return ReferencePtr(const_cast<Reference*>(this));
-    }
-    ReferencePtr r = _instance->referenceFactory()->copy(this);
+    ReferencePtr r = clone();
     r->_compress = newCompress;
-    r->_overrideCompress = true;
     return r;
 }
 
-bool
-IceInternal::Reference::getCompressOverride(bool& compress) const
+optional<bool>
+IceInternal::Reference::getCompressOverride() const noexcept
 {
     DefaultsAndOverridesPtr defaultsAndOverrides = getInstance()->defaultsAndOverrides();
-    if(defaultsAndOverrides->overrideCompress)
-    {
-        compress = defaultsAndOverrides->overrideCompressValue;
-    }
-    else if(_overrideCompress)
-    {
-        compress = _compress;
-    }
-    else
-    {
-        return false;
-    }
-    return true;
+    optional<bool> compress =
+        defaultsAndOverrides->overrideCompress.has_value() ? defaultsAndOverrides->overrideCompress : _compress;
+    return compress;
 }
 
-Int
-Reference::hash() const
+size_t
+Reference::hash() const noexcept
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(hashMutex);
-    if(!_hashInitialized)
-    {
-        _hashValue = hashInit();
-        _hashInitialized = true;
-    }
-    return _hashValue;
+    size_t h = 5381;
+    hashAdd(h, static_cast<int32_t>(_mode));
+    hashAdd(h, _identity.name);
+    hashAdd(h, _identity.category);
+    hashAdd(h, _context->getValue());
+    hashAdd(h, _facet);
+    hashAdd(h, _compress);
+    // We don't include protocol and encoding in the hash; they are using 1.0 and 1.1, respectively.
+    hashAdd(h, _invocationTimeout.count());
+    return h;
 }
 
 void
@@ -203,20 +129,20 @@ IceInternal::Reference::streamWrite(OutputStream* s) const
     //
     // For compatibility with the old FacetPath.
     //
-    if(_facet.empty())
+    if (_facet.empty())
     {
-        s->write(static_cast<string*>(0), static_cast<string*>(0));
+        s->write(static_cast<string*>(nullptr), static_cast<string*>(nullptr));
     }
     else
     {
         s->write(&_facet, &_facet + 1);
     }
 
-    s->write(static_cast<Byte>(_mode));
+    s->write(static_cast<uint8_t>(_mode));
 
-    s->write(_secure);
+    s->write(false); // secure, no longer used
 
-    if(s->getEncoding() != Ice::Encoding_1_0)
+    if (s->getEncoding() != Ice::Encoding_1_0)
     {
         s->write(_protocol);
         s->write(_encoding);
@@ -248,7 +174,7 @@ IceInternal::Reference::toString() const
     // the identity string in quotes.
     //
 
-    if(id.find_first_of(separators) != string::npos)
+    if (id.find_first_of(separators) != string::npos)
     {
         s << '"' << id << '"';
     }
@@ -257,7 +183,7 @@ IceInternal::Reference::toString() const
         s << id;
     }
 
-    if(!_facet.empty())
+    if (!_facet.empty())
     {
         s << " -f ";
 
@@ -267,7 +193,7 @@ IceInternal::Reference::toString() const
         // the reference parser uses as separators, then we enclose
         // the facet string in quotes.
         //
-        if(fs.find_first_of(separators) != string::npos)
+        if (fs.find_first_of(separators) != string::npos)
         {
             s << '"' << fs << '"';
         }
@@ -277,11 +203,11 @@ IceInternal::Reference::toString() const
         }
     }
 
-    switch(_mode)
+    switch (_mode)
     {
         case ModeTwoway:
         {
-            s << " -t";
+            // Don't print the default mode.
             break;
         }
 
@@ -310,82 +236,66 @@ IceInternal::Reference::toString() const
         }
     }
 
-    if(_secure)
+    if (_protocol != Protocol_1_0)
     {
-        s << " -s";
+        // We print the protocol unless it's 1.0.
+        s << " -p " << _protocol;
     }
 
-    if(_protocol != Ice::Protocol_1_0)
+    // We print the encoding if it's not 1.1 or if Ice.Default.EncodingVersion is set to something other than 1.1.
+    if (_encoding != Ice::Encoding_1_1 || _instance->defaultsAndOverrides()->defaultEncoding != Ice::Encoding_1_1)
     {
-        //
-        // We only print the protocol if it's not 1.0. It's fine as
-        // long as we don't add Ice.Default.ProtocolVersion, a
-        // stringified proxy will convert back to the same proxy with
-        // stringToProxy.
-        //
-        s << " -p " << _protocol;
+        s << " -e " << _encoding;
     }
 
-    //
-    // Always print the encoding version to ensure a stringified proxy
-    // will convert back to a proxy with the same encoding with
-    // stringToProxy (and won't use Ice.Default.EncodingVersion).
-    //
-    s << " -e " << _encoding;
-
     return s.str();
 
     // Derived class writes the remainder of the string.
 }
 
 bool
-IceInternal::Reference::operator==(const Reference& r) const
+IceInternal::Reference::operator==(const Reference& r) const noexcept
 {
     //
     // Note: if(this == &r) test is performed by each non-abstract derived class.
     //
 
-    if(_mode != r._mode)
+    if (_mode != r._mode)
     {
         return false;
     }
 
-    if(_secure != r._secure)
+    if (_identity != r._identity)
     {
         return false;
     }
 
-    if(_identity != r._identity)
+    if (_context->getValue() != r._context->getValue())
     {
         return false;
     }
 
-    if(_context->getValue() != r._context->getValue())
+    if (_facet != r._facet)
     {
         return false;
     }
 
-    if(_facet != r._facet)
+    if (_compress != r._compress)
     {
         return false;
     }
 
-    if((_overrideCompress != r._overrideCompress) || (_overrideCompress && _compress != r._compress))
+    if (_protocol != r._protocol)
     {
         return false;
     }
 
-    if(_protocol != r._protocol)
+    if (_encoding != r._encoding)
     {
         return false;
     }
 
-    if(_encoding != r._encoding)
-    {
-        return false;
-    }
-
-    if(_invocationTimeout != r._invocationTimeout)
+    if (_invocationTimeout != r._invocationTimeout)
     {
         return false;
     }
@@ -393,100 +303,80 @@ IceInternal::Reference::operator==(const Reference& r) const
 }
 
 bool
-IceInternal::Reference::operator<(const Reference& r) const
+IceInternal::Reference::operator<(const Reference& r) const noexcept
 {
     //
     // Note: if(this == &r) test is performed by each non-abstract derived class.
     //
 
-    if(_mode < r._mode)
+    if (_mode < r._mode)
     {
         return true;
     }
-    else if(r._mode < _mode)
+    else if (r._mode < _mode)
     {
         return false;
     }
 
-    if(_identity < r._identity)
+    if (_identity < r._identity)
     {
         return true;
     }
-    else if(r._identity < _identity)
+    else if (r._identity < _identity)
     {
         return false;
     }
 
-    if(_context->getValue() < r._context->getValue())
+    if (_context->getValue() < r._context->getValue())
     {
         return true;
     }
-    else if(r._context->getValue() < _context->getValue())
+    else if (r._context->getValue() < _context->getValue())
     {
         return false;
     }
 
-    if(_facet < r._facet)
+    if (_facet < r._facet)
     {
         return true;
     }
-    else if(r._facet < _facet)
+    else if (r._facet < _facet)
     {
         return false;
     }
 
-    if(!_overrideCompress && r._overrideCompress)
+    if (_compress < r._compress)
     {
         return true;
     }
-    else if(r._overrideCompress < _overrideCompress)
+    else if (r._compress < _compress)
     {
         return false;
     }
-    else if(_overrideCompress)
-    {
-        if(!_compress && r._compress)
-        {
-            return true;
-        }
-        else if(r._compress < _compress)
-        {
-            return false;
-        }
-    }
 
-    if(!_secure && r._secure)
+    if (_protocol < r._protocol)
     {
         return true;
     }
-    else if(r._secure < _secure)
+    else if (r._protocol < _protocol)
     {
         return false;
     }
 
-    if(_protocol < r._protocol)
+    if (_encoding < r._encoding)
     {
         return true;
     }
-    else if(r._protocol < _protocol)
+    else if (r._encoding < _encoding)
     {
         return false;
     }
 
-    if(_encoding < r._encoding)
+    if (_invocationTimeout < r._invocationTimeout)
     {
         return true;
     }
-    else if(r._encoding < _encoding)
-    {
-        return false;
-    }
-
-    if(_invocationTimeout < r._invocationTimeout)
-    {
-        return true;
-    }
-    else if(r._invocationTimeout < _invocationTimeout)
+    else if (r._invocationTimeout < _invocationTimeout)
     {
         return false;
     }
@@ -494,195 +384,134 @@ IceInternal::Reference::operator<(const Reference& r) const
     return false;
 }
 
-#ifndef ICE_CPP11_COMPILER
-class ConnectionIsDatagram : public unary_function<ConnectionIPtr, bool>
-{
-public:
-
-    bool
-    operator()(ConnectionIPtr p) const
-    {
-        return p->endpoint()->datagram();
-    }
-};
-
-class ConnectionIsSecure : public unary_function<ConnectionIPtr, bool>
-{
-public:
-
-    bool
-    operator()(ConnectionIPtr p) const
-    {
-        return p->endpoint()->secure();
-    }
-};
-#endif
-
-IceInternal::Reference::Reference(const InstancePtr& instance,
-                                  const CommunicatorPtr& communicator,
-                                  const Identity& id,
-                                  const string& facet,
-                                  Mode mode,
-                                  bool secure,
-                                  const ProtocolVersion& protocol,
-                                  const EncodingVersion& encoding,
-                                  int invocationTimeout,
-                                  const Ice::Context& ctx) :
-    _hashInitialized(false),
-    _instance(instance),
-    _communicator(communicator),
-    _mode(mode),
-    _secure(secure),
-    _identity(id),
-    _context(new SharedContext(ctx)),
-    _facet(facet),
-    _protocol(protocol),
-    _encoding(encoding),
-    _invocationTimeout(invocationTimeout),
-    _overrideCompress(false),
-    _compress(false)
-{
-}
-
-IceInternal::Reference::Reference(const Reference& r) :
-    IceUtil::Shared(),
-    _hashInitialized(false),
-    _instance(r._instance),
-    _communicator(r._communicator),
-    _mode(r._mode),
-    _secure(r._secure),
-    _identity(r._identity),
-    _context(r._context),
-    _facet(r._facet),
-    _protocol(r._protocol),
-    _encoding(r._encoding),
-    _invocationTimeout(r._invocationTimeout),
-    _overrideCompress(r._overrideCompress),
-    _compress(r._compress)
+IceInternal::Reference::Reference(
+    InstancePtr instance,
+    CommunicatorPtr communicator,
+    Identity id,
+    string facet,
+    Mode mode,
+    std::optional<bool> compress,
+    ProtocolVersion protocol,
+    EncodingVersion encoding,
+    chrono::milliseconds invocationTimeout,
+    Context ctx)
+    : _instance(std::move(instance)),
+      _communicator(std::move(communicator)),
+      _mode(mode),
+      _compress(compress),
+      _identity(std::move(id)),
+      _context(make_shared<SharedContext>(std::move(ctx))),
+      _facet(std::move(facet)),
+      _protocol(protocol),
+      _encoding(encoding),
+      _invocationTimeout(invocationTimeout)
+{
+}
+
+IceInternal::Reference::Reference(const Reference& r)
+    : enable_shared_from_this<Reference>(),
+      _instance(r._instance),
+      _communicator(r._communicator),
+      _mode(r._mode),
+      _compress(r._compress),
+      _identity(r._identity),
+      _context(r._context),
+      _facet(r._facet),
+      _protocol(r._protocol),
+      _encoding(r._encoding),
+      _invocationTimeout(r._invocationTimeout)
+{
+}
+
+IceInternal::FixedReference::FixedReference(
+    InstancePtr instance,
+    CommunicatorPtr communicator,
+    Identity id,
+    string facet,
+    Mode mode,
+    std::optional<bool> compress,
+    ProtocolVersion protocol,
+    EncodingVersion encoding,
+    ConnectionIPtr fixedConnection,
+    chrono::milliseconds invocationTimeout,
+    Ice::Context context)
+    : Reference(
+          std::move(instance),
+          std::move(communicator),
+          std::move(id),
+          std::move(facet),
+          mode,
+          compress,
+          protocol,
+          encoding,
+          invocationTimeout,
+          std::move(context)),
+      _fixedConnection(std::move(fixedConnection))
 {
 }
 
-int
-IceInternal::Reference::hashInit() const
-{
-    Int h = 5381;
-    hashAdd(h, static_cast<Int>(_mode));
-    hashAdd(h, _secure);
-    hashAdd(h, _identity.name);
-    hashAdd(h, _identity.category);
-    hashAdd(h, _context->getValue());
-    hashAdd(h, _facet);
-    hashAdd(h, _overrideCompress);
-    if(_overrideCompress)
-    {
-        hashAdd(h, _compress);
-    }
-    hashAdd(h, _protocol.major);
-    hashAdd(h, _protocol.minor);
-    hashAdd(h, _encoding.major);
-    hashAdd(h, _encoding.minor);
-    hashAdd(h, _invocationTimeout);
-    return h;
-}
-
-IceUtil::Shared* IceInternal::upCast(IceInternal::FixedReference* p) { return p; }
-
-IceInternal::FixedReference::FixedReference(const InstancePtr& instance,
-                                            const CommunicatorPtr& communicator,
-                                            const Identity& id,
-                                            const string& facet,
-                                            Mode mode,
-                                            bool secure,
-                                            const ProtocolVersion& protocol,
-                                            const EncodingVersion& encoding,
-                                            const ConnectionIPtr& fixedConnection,
-                                            int invocationTimeout,
-                                            const Ice::Context& context,
-                                            const IceUtil::Optional<bool>& compress) :
-    Reference(instance, communicator, id, facet, mode, secure, protocol, encoding, invocationTimeout, context),
-    _fixedConnection(fixedConnection)
-{
-    if(compress)
-    {
-        _overrideCompress = true;
-        _compress = *compress;
-    }
-}
-
 vector<EndpointIPtr>
 IceInternal::FixedReference::getEndpoints() const
 {
-    return vector<EndpointIPtr>();
+    return {};
 }
 
 string
 IceInternal::FixedReference::getAdapterId() const
 {
-    return string();
+    return {};
 }
 
 bool
-IceInternal::FixedReference::getCollocationOptimized() const
+IceInternal::FixedReference::getCollocationOptimized() const noexcept
 {
     return false;
 }
 
 bool
-IceInternal::FixedReference::getCacheConnection() const
+IceInternal::FixedReference::getCacheConnection() const noexcept
 {
     return true;
 }
 
-bool
-IceInternal::FixedReference::getPreferSecure() const
-{
-    return false;
-}
-
 Ice::EndpointSelectionType
-IceInternal::FixedReference::getEndpointSelection() const
+IceInternal::FixedReference::getEndpointSelection() const noexcept
 {
-    return ICE_ENUM(EndpointSelectionType, Random);
+    return EndpointSelectionType::Random;
 }
 
-int
-IceInternal::FixedReference::getLocatorCacheTimeout() const
+chrono::milliseconds
+IceInternal::FixedReference::getLocatorCacheTimeout() const noexcept
 {
-    return 0;
+    return 0ms;
 }
 
 string
 IceInternal::FixedReference::getConnectionId() const
 {
-    return string();
-}
-
-IceUtil::Optional<int>
-IceInternal::FixedReference::getTimeout() const
-{
-    return IceUtil::Optional<int>();
+    return {};
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeEndpoints(const vector<EndpointIPtr>& /*newEndpoints*/) const
+IceInternal::FixedReference::changeEndpoints(vector<EndpointIPtr> /*newEndpoints*/) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeAdapterId(const string& /*newAdapterId*/) const
+IceInternal::FixedReference::changeAdapterId(string /*newAdapterId*/) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeLocator(const LocatorPrxPtr&) const
+IceInternal::FixedReference::changeLocator(optional<LocatorPrx>) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeRouter(const RouterPrxPtr&) const
+IceInternal::FixedReference::changeRouter(optional<RouterPrx>) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
 }
@@ -699,12 +528,6 @@ IceInternal::FixedReference::changeCacheConnection(bool) const
     throw FixedProxyException(__FILE__, __LINE__);
 }
 
-ReferencePtr
-IceInternal::FixedReference::changePreferSecure(bool) const
-{
-    throw FixedProxyException(__FILE__, __LINE__);
-}
-
 ReferencePtr
 IceInternal::FixedReference::changeEndpointSelection(EndpointSelectionType) const
 {
@@ -712,43 +535,33 @@ IceInternal::FixedReference::changeEndpointSelection(EndpointSelectionType) cons
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeLocatorCacheTimeout(int) const
+IceInternal::FixedReference::changeLocatorCacheTimeout(chrono::milliseconds) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeTimeout(int) const
+IceInternal::FixedReference::changeConnectionId(string) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeConnectionId(const string&) const
+IceInternal::FixedReference::changeConnection(Ice::ConnectionIPtr newConnection) const
 {
-    throw FixedProxyException(__FILE__, __LINE__);
-}
-
-ReferencePtr
-IceInternal::FixedReference::changeConnection(const Ice::ConnectionIPtr& newConnection) const
-{
-    if(newConnection == _fixedConnection)
-    {
-        return FixedReferencePtr(const_cast<FixedReference*>(this));
-    }
-    FixedReferencePtr r = FixedReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
-    r->_fixedConnection = newConnection;
+    FixedReferencePtr r = dynamic_pointer_cast<FixedReference>(clone());
+    r->_fixedConnection = std::move(newConnection);
     return r;
 }
 
 bool
-IceInternal::FixedReference::isIndirect() const
+IceInternal::FixedReference::isIndirect() const noexcept
 {
     return false;
 }
 
 bool
-IceInternal::FixedReference::isWellKnown() const
+IceInternal::FixedReference::isWellKnown() const noexcept
 {
     return false;
 }
@@ -760,88 +573,72 @@ IceInternal::FixedReference::streamWrite(OutputStream*) const
 }
 
 PropertyDict
-IceInternal::FixedReference::toProperty(const string&) const
+IceInternal::FixedReference::toProperty(string) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
 }
 
 RequestHandlerPtr
-IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrxPtr& proxy) const
+IceInternal::FixedReference::getRequestHandler() const
 {
-    switch(getMode())
-    {
-    case Reference::ModeTwoway:
-    case Reference::ModeOneway:
-    case Reference::ModeBatchOneway:
+    // We need to perform all these checks here and not in the constructor because changeConnection() clones then
+    // sets the connection.
+
+    switch (getMode())
     {
-        if(_fixedConnection->endpoint()->datagram())
+        case Reference::ModeTwoway:
+        case Reference::ModeOneway:
+        case Reference::ModeBatchOneway:
         {
-            throw NoEndpointException(__FILE__, __LINE__, toString());
+            if (_fixedConnection->endpoint()->datagram())
+            {
+                throw NoEndpointException(
+                    __FILE__,
+                    __LINE__,
+                    ObjectPrx::_fromReference(const_cast<FixedReference*>(this)->shared_from_this()));
+            }
+            break;
         }
-        break;
-    }
 
-    case Reference::ModeDatagram:
-    case Reference::ModeBatchDatagram:
-    {
-        if(!_fixedConnection->endpoint()->datagram())
+        case Reference::ModeDatagram:
+        case Reference::ModeBatchDatagram:
         {
-            throw NoEndpointException(__FILE__, __LINE__, toString());
+            if (!_fixedConnection->endpoint()->datagram())
+            {
+                throw NoEndpointException(
+                    __FILE__,
+                    __LINE__,
+                    ObjectPrx::_fromReference(const_cast<FixedReference*>(this)->shared_from_this()));
+            }
+            break;
         }
-        break;
-    }
-    }
-
-    //
-    // If a secure connection is requested or secure overrides is set,
-    // check if the connection is secure.
-    //
-    bool secure;
-    DefaultsAndOverridesPtr defaultsAndOverrides = getInstance()->defaultsAndOverrides();
-    if(defaultsAndOverrides->overrideSecure)
-    {
-        secure = defaultsAndOverrides->overrideSecureValue;
-    }
-    else
-    {
-        secure = getSecure();
-    }
-    if(secure && !_fixedConnection->endpoint()->secure())
-    {
-        throw NoEndpointException(__FILE__, __LINE__, toString());
     }
 
     _fixedConnection->throwException(); // Throw in case our connection is already destroyed.
 
-    bool compress = false;
-    if(defaultsAndOverrides->overrideCompress)
-    {
-        compress = defaultsAndOverrides->overrideCompressValue;
-    }
-    else if(_overrideCompress)
-    {
-        compress = _compress;
-    }
+    DefaultsAndOverridesPtr defaultsAndOverrides = getInstance()->defaultsAndOverrides();
+    bool compress = defaultsAndOverrides->overrideCompress.has_value() ? *defaultsAndOverrides->overrideCompress
+                                                                       : getCompress().value_or(false);
 
-    ReferencePtr ref = const_cast<FixedReference*>(this);
-    return proxy->_setRequestHandler(ICE_MAKE_SHARED(ConnectionRequestHandler, ref, _fixedConnection, compress));
+    ReferencePtr ref = const_cast<FixedReference*>(this)->shared_from_this();
+    return make_shared<FixedRequestHandler>(ref, _fixedConnection, compress);
 }
 
-BatchRequestQueuePtr
-IceInternal::FixedReference::getBatchRequestQueue() const
+const BatchRequestQueuePtr&
+IceInternal::FixedReference::getBatchRequestQueue() const noexcept
 {
     return _fixedConnection->getBatchRequestQueue();
 }
 
 bool
-IceInternal::FixedReference::operator==(const Reference& r) const
+IceInternal::FixedReference::operator==(const Reference& r) const noexcept
 {
-    if(this == &r)
+    if (this == &r)
     {
         return true;
     }
-    const FixedReference* rhs = dynamic_cast<const FixedReference*>(&r);
-    if(!rhs || !Reference::operator==(r))
+    const auto* rhs = dynamic_cast<const FixedReference*>(&r);
+    if (!rhs || !Reference::operator==(r))
     {
         return false;
     }
@@ -849,23 +646,23 @@ IceInternal::FixedReference::operator==(const Reference& r) const
 }
 
 bool
-IceInternal::FixedReference::operator<(const Reference& r) const
+IceInternal::FixedReference::operator<(const Reference& r) const noexcept
 {
-    if(this == &r)
+    if (this == &r)
     {
         return false;
     }
-    if(Reference::operator<(r))
+    if (Reference::operator<(r))
     {
         return true;
     }
-    if(!Reference::operator==(r))
+    if (!Reference::operator==(r))
     {
         return false;
     }
 
-    const FixedReference* rhs = dynamic_cast<const FixedReference*>(&r);
-    if(!rhs)
+    const auto* rhs = dynamic_cast<const FixedReference*>(&r);
+    if (!rhs)
     {
         assert(dynamic_cast<const RoutableReference*>(&r));
         return false; // As a rule, routable references are superior to fixed references.
@@ -876,50 +673,50 @@ IceInternal::FixedReference::operator<(const Reference& r) const
 ReferencePtr
 IceInternal::FixedReference::clone() const
 {
-    return new FixedReference(*this);
-}
-
-IceInternal::FixedReference::FixedReference(const FixedReference& r) :
-    Reference(r),
-    _fixedConnection(r._fixedConnection)
-{
-}
-
-IceUtil::Shared* IceInternal::upCast(IceInternal::RoutableReference* p) { return p; }
-
-IceInternal::RoutableReference::RoutableReference(const InstancePtr& instance,
-                                                  const CommunicatorPtr& communicator,
-                                                  const Identity& id,
-                                                  const string& facet,
-                                                  Mode mode,
-                                                  bool secure,
-                                                  const ProtocolVersion& protocol,
-                                                  const EncodingVersion& encoding,
-                                                  const vector<EndpointIPtr>& endpoints,
-                                                  const string& adapterId,
-                                                  const LocatorInfoPtr& locatorInfo,
-                                                  const RouterInfoPtr& routerInfo,
-                                                  bool collocationOptimized,
-                                                  bool cacheConnection,
-                                                  bool preferSecure,
-                                                  EndpointSelectionType endpointSelection,
-                                                  int locatorCacheTimeout,
-                                                  int invocationTimeout,
-                                                  const Ice::Context& ctx) :
-    Reference(instance, communicator, id, facet, mode, secure, protocol, encoding, invocationTimeout, ctx),
-    _endpoints(endpoints),
-    _adapterId(adapterId),
-    _locatorInfo(locatorInfo),
-    _routerInfo(routerInfo),
-    _collocationOptimized(collocationOptimized),
-    _cacheConnection(cacheConnection),
-    _preferSecure(preferSecure),
-    _endpointSelection(endpointSelection),
-    _locatorCacheTimeout(locatorCacheTimeout),
-    _overrideTimeout(false),
-    _timeout(-1)
+    return make_shared<FixedReference>(*this);
+}
+
+IceInternal::RoutableReference::RoutableReference(
+    InstancePtr instance,
+    CommunicatorPtr communicator,
+    Identity id,
+    string facet,
+    Mode mode,
+    optional<bool> compress,
+    ProtocolVersion protocol,
+    EncodingVersion encoding,
+    vector<EndpointIPtr> endpoints,
+    string adapterId,
+    LocatorInfoPtr locatorInfo,
+    RouterInfoPtr routerInfo,
+    bool collocationOptimized,
+    bool cacheConnection,
+    EndpointSelectionType endpointSelection,
+    chrono::milliseconds locatorCacheTimeout,
+    chrono::milliseconds invocationTimeout,
+    Ice::Context ctx)
+    : Reference(
+          std::move(instance),
+          std::move(communicator),
+          std::move(id),
+          std::move(facet),
+          mode,
+          compress,
+          protocol,
+          encoding,
+          invocationTimeout,
+          std::move(ctx)),
+      _endpoints(std::move(endpoints)),
+      _adapterId(std::move(adapterId)),
+      _locatorInfo(std::move(locatorInfo)),
+      _routerInfo(std::move(routerInfo)),
+      _collocationOptimized(collocationOptimized),
+      _cacheConnection(cacheConnection),
+      _endpointSelection(endpointSelection),
+      _locatorCacheTimeout(locatorCacheTimeout)
 {
     assert(_adapterId.empty() || _endpoints.empty());
+    setBatchRequestQueue();
 }
 
 vector<EndpointIPtr>
@@ -935,43 +732,37 @@ IceInternal::RoutableReference::getAdapterId() const
 }
 
 LocatorInfoPtr
-IceInternal::RoutableReference::getLocatorInfo() const
+IceInternal::RoutableReference::getLocatorInfo() const noexcept
 {
     return _locatorInfo;
 }
 
 RouterInfoPtr
-IceInternal::RoutableReference::getRouterInfo() const
+IceInternal::RoutableReference::getRouterInfo() const noexcept
 {
     return _routerInfo;
 }
 
 bool
-IceInternal::RoutableReference::getCollocationOptimized() const
+IceInternal::RoutableReference::getCollocationOptimized() const noexcept
 {
     return _collocationOptimized;
 }
 
 bool
-IceInternal::RoutableReference::getCacheConnection() const
+IceInternal::RoutableReference::getCacheConnection() const noexcept
 {
     return _cacheConnection;
 }
 
-bool
-IceInternal::RoutableReference::getPreferSecure() const
-{
-    return _preferSecure;
-}
-
 Ice::EndpointSelectionType
-IceInternal::RoutableReference::getEndpointSelection() const
+IceInternal::RoutableReference::getEndpointSelection() const noexcept
 {
     return _endpointSelection;
 }
 
-int
-IceInternal::RoutableReference::getLocatorCacheTimeout() const
+chrono::milliseconds
+IceInternal::RoutableReference::getLocatorCacheTimeout() const noexcept
 {
     return _locatorCacheTimeout;
 }
@@ -982,20 +773,22 @@ IceInternal::RoutableReference::getConnectionId() const
     return _connectionId;
 }
 
-IceUtil::Optional<int>
-IceInternal::RoutableReference::getTimeout() const
+ReferencePtr
+IceInternal::RoutableReference::changeMode(Mode newMode) const
 {
-    return _overrideTimeout ? IceUtil::Optional<int>(_timeout) : IceUtil::None;
+    ReferencePtr r = Reference::changeMode(newMode);
+    static_pointer_cast<RoutableReference>(r)->setBatchRequestQueue();
+    return r;
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeEncoding(const Ice::EncodingVersion& encoding) const
+IceInternal::RoutableReference::changeEncoding(Ice::EncodingVersion encoding) const
 {
     ReferencePtr r = Reference::changeEncoding(encoding);
-    if(r.get() != const_cast<RoutableReference*>(this))
+    if (r.get() != const_cast<RoutableReference*>(this))
     {
-        LocatorInfoPtr& locInfo = RoutableReferencePtr::dynamicCast(r)->_locatorInfo;
-        if(locInfo && locInfo->getLocator()->ice_getEncodingVersion() != encoding)
+        LocatorInfoPtr& locInfo = dynamic_pointer_cast<RoutableReference>(r)->_locatorInfo;
+        if (locInfo && locInfo->getLocator()->ice_getEncodingVersion() != encoding)
         {
             locInfo = getInstance()->locatorManager()->get(locInfo->getLocator()->ice_encodingVersion(encoding));
         }
@@ -1008,79 +801,60 @@ IceInternal::RoutableReference::changeCompress(bool newCompress) const
 {
     ReferencePtr r = Reference::changeCompress(newCompress);
     // Also override the compress flag on the endpoints if it was updated.
-    if(r.get() != const_cast<RoutableReference*>(this) && !_endpoints.empty())
+    if (r.get() != const_cast<RoutableReference*>(this) && !_endpoints.empty())
     {
         vector<EndpointIPtr> newEndpoints;
-        for(vector<EndpointIPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p)
+        newEndpoints.reserve(_endpoints.size());
+        for (const auto& endpoint : _endpoints)
         {
-            newEndpoints.push_back((*p)->compress(newCompress));
+            newEndpoints.push_back(endpoint->compress(newCompress));
         }
-        RoutableReferencePtr::dynamicCast(r)->_endpoints = newEndpoints;
+        dynamic_pointer_cast<RoutableReference>(r)->_endpoints = newEndpoints;
     }
     return r;
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeEndpoints(const vector<EndpointIPtr>& newEndpoints) const
+IceInternal::RoutableReference::changeEndpoints(vector<EndpointIPtr> newEndpoints) const
 {
-    if(newEndpoints == _endpoints)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
-    r->_endpoints = newEndpoints;
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    r->_endpoints = std::move(newEndpoints);
     r->applyOverrides(r->_endpoints);
     r->_adapterId.clear();
     return r;
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeAdapterId(const string& newAdapterId) const
+IceInternal::RoutableReference::changeAdapterId(string newAdapterId) const
 {
-    if(newAdapterId == _adapterId)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
-    r->_adapterId = newAdapterId;
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    r->_adapterId = std::move(newAdapterId);
     r->_endpoints.clear();
     return r;
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeLocator(const LocatorPrxPtr& newLocator) const
+IceInternal::RoutableReference::changeLocator(optional<LocatorPrx> newLocator) const
 {
-    LocatorInfoPtr newLocatorInfo = getInstance()->locatorManager()->get(newLocator);
-    if(newLocatorInfo == _locatorInfo)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
-    r->_locatorInfo = newLocatorInfo;
+    LocatorInfoPtr newLocatorInfo = newLocator ? getInstance()->locatorManager()->get(newLocator.value()) : nullptr;
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    r->_locatorInfo = std::move(newLocatorInfo);
     return r;
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeRouter(const RouterPrxPtr& newRouter) const
+IceInternal::RoutableReference::changeRouter(optional<RouterPrx> newRouter) const
 {
-    RouterInfoPtr newRouterInfo = getInstance()->routerManager()->get(newRouter);
-    if(newRouterInfo == _routerInfo)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
-    r->_routerInfo = newRouterInfo;
+    RouterInfoPtr newRouterInfo = newRouter ? getInstance()->routerManager()->get(newRouter.value()) : nullptr;
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    r->_routerInfo = std::move(newRouterInfo);
     return r;
 }
 
 ReferencePtr
 IceInternal::RoutableReference::changeCollocationOptimized(bool newCollocationOptimized) const
 {
-    if(newCollocationOptimized == _collocationOptimized)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
     r->_collocationOptimized = newCollocationOptimized;
     return r;
 }
@@ -1088,88 +862,39 @@ IceInternal::RoutableReference::changeCollocationOptimized(bool newCollocationOp
 ReferencePtr
 IceInternal::RoutableReference::changeCacheConnection(bool newCache) const
 {
-    if(newCache == _cacheConnection)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
     r->_cacheConnection = newCache;
     return r;
 }
 
-ReferencePtr
-IceInternal::RoutableReference::changePreferSecure(bool newPreferSecure) const
-{
-    if(newPreferSecure == _preferSecure)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
-    r->_preferSecure = newPreferSecure;
-    return r;
-}
-
 ReferencePtr
 IceInternal::RoutableReference::changeEndpointSelection(EndpointSelectionType newType) const
 {
-    if(newType == _endpointSelection)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
     r->_endpointSelection = newType;
     return r;
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeLocatorCacheTimeout(int timeout) const
+IceInternal::RoutableReference::changeLocatorCacheTimeout(chrono::milliseconds timeout) const
 {
-    if(timeout == _locatorCacheTimeout)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
     r->_locatorCacheTimeout = timeout;
     return r;
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeTimeout(int newTimeout) const
-{
-    if(_overrideTimeout && newTimeout == _timeout)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
-    r->_timeout = newTimeout;
-    r->_overrideTimeout = true;
-    if(!_endpoints.empty()) // Also override the timeout on the endpoints.
-    {
-        vector<EndpointIPtr> newEndpoints;
-        for(vector<EndpointIPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p)
-        {
-            newEndpoints.push_back((*p)->timeout(newTimeout));
-        }
-        r->_endpoints = newEndpoints;
-    }
-    return r;
-}
-
-ReferencePtr
-IceInternal::RoutableReference::changeConnectionId(const string& id) const
+IceInternal::RoutableReference::changeConnectionId(string id) const
 {
-    if(id == _connectionId)
-    {
-        return RoutableReferencePtr(const_cast<RoutableReference*>(this));
-    }
-    RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this));
+    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
     r->_connectionId = id;
-    if(!_endpoints.empty()) // Also override the connection id on the endpoints.
+    if (!_endpoints.empty()) // Also override the connection id on the endpoints.
     {
         vector<EndpointIPtr> newEndpoints;
-        for(vector<EndpointIPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p)
+        newEndpoints.reserve(_endpoints.size());
+        for (const auto& endpoint : _endpoints)
         {
-            newEndpoints.push_back((*p)->connectionId(id));
+            newEndpoints.push_back(endpoint->connectionId(id));
         }
         r->_endpoints = newEndpoints;
     }
@@ -1177,30 +902,30 @@ IceInternal::RoutableReference::changeConnectionId(const string& id) const
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeConnection(const Ice::ConnectionIPtr& connection) const
-{
-    return new FixedReference(getInstance(),
-                              getCommunicator(),
-                              getIdentity(),
-                              getFacet(),
-                              getMode(),
-                              getSecure(),
-                              getProtocol(),
-                              getEncoding(),
-                              connection,
-                              getInvocationTimeout(),
-                              getContext()->getValue(),
-                              getCompress());
+IceInternal::RoutableReference::changeConnection(Ice::ConnectionIPtr connection) const
+{
+    return make_shared<FixedReference>(
+        getInstance(),
+        getCommunicator(),
+        getIdentity(),
+        getFacet(),
+        getMode(),
+        getCompress(),
+        getProtocol(),
+        getEncoding(),
+        std::move(connection),
+        getInvocationTimeout(),
+        getContext()->getValue());
 }
 
 bool
-IceInternal::RoutableReference::isIndirect() const
+IceInternal::RoutableReference::isIndirect() const noexcept
 {
     return _endpoints.empty();
 }
 
 bool
-IceInternal::RoutableReference::isWellKnown() const
+IceInternal::RoutableReference::isWellKnown() const noexcept
 {
     return _endpoints.empty() && _adapterId.empty();
 }
@@ -1210,15 +935,15 @@ IceInternal::RoutableReference::streamWrite(OutputStream* s) const
 {
     Reference::streamWrite(s);
 
-    Int sz = static_cast<Int>(_endpoints.size());
+    auto sz = static_cast<int32_t>(_endpoints.size());
     s->writeSize(sz);
-    if(sz)
+    if (sz)
     {
         assert(_adapterId.empty());
-        for(vector<EndpointIPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p)
+        for (const auto& endpoint : _endpoints)
         {
-            s->write((*p)->type());
-            (*p)->streamWrite(s);
+            s->write(endpoint->type());
+            endpoint->streamWrite(s);
         }
     }
     else
@@ -1239,19 +964,19 @@ IceInternal::RoutableReference::toString() const
     //
     string result = Reference::toString();
 
-    if(!_endpoints.empty())
+    if (!_endpoints.empty())
     {
-        for(vector<EndpointIPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p)
+        for (const auto& endpoint : _endpoints)
         {
-            string endp = (*p)->toString();
-            if(!endp.empty())
+            string endp = endpoint->toString();
+            if (!endp.empty())
             {
                 result.append(":");
                 result.append(endp);
             }
         }
     }
-    else if(!_adapterId.empty())
+    else if (!_adapterId.empty())
     {
         result.append(" @ ");
 
@@ -1261,7 +986,7 @@ IceInternal::RoutableReference::toString() const
         // adapter id string in quotes.
         //
         string a = escapeString(_adapterId, "", getInstance()->toStringMode());
-        if(a.find_first_of(" :@") != string::npos)
+        if (a.find_first_of(" :@") != string::npos)
         {
             result.append("\"");
             result.append(a);
@@ -1280,120 +1005,106 @@ IceInternal::RoutableReference::toString() const
 }
 
 PropertyDict
-IceInternal::RoutableReference::toProperty(const string& prefix) const
+IceInternal::RoutableReference::toProperty(string prefix) const
 {
     Ice::PropertyDict properties;
 
-    properties[prefix] = toString();
     properties[prefix + ".CollocationOptimized"] = _collocationOptimized ? "1" : "0";
     properties[prefix + ".ConnectionCached"] = _cacheConnection ? "1" : "0";
-    properties[prefix + ".PreferSecure"] = _preferSecure ? "1" : "0";
-    properties[prefix + ".EndpointSelection"] = _endpointSelection == ICE_ENUM(EndpointSelectionType, Random) ? "Random" : "Ordered";
-    {
-        ostringstream s;
-        s << _locatorCacheTimeout;
-        properties[prefix + ".LocatorCacheTimeout"] = s.str();
-    }
-    {
-        ostringstream s;
-        s << getInvocationTimeout();
-        properties[prefix + ".InvocationTimeout"] = s.str();
-    }
-    if(_routerInfo)
+    properties[prefix + ".EndpointSelection"] =
+        _endpointSelection == EndpointSelectionType::Random ? "Random" : "Ordered";
+    properties[prefix + ".LocatorCacheTimeout"] =
+        to_string(chrono::duration_cast<chrono::seconds>(_locatorCacheTimeout).count());
+    properties[prefix + ".InvocationTimeout"] = to_string(getInvocationTimeout().count());
+
+    if (_routerInfo)
     {
         PropertyDict routerProperties = _routerInfo->getRouter()->_getReference()->toProperty(prefix + ".Router");
-        for(PropertyDict::const_iterator p = routerProperties.begin(); p != routerProperties.end(); ++p)
+        for (const auto& routerProp : routerProperties)
         {
-            properties[p->first] = p->second;
+            properties[routerProp.first] = routerProp.second;
         }
     }
 
-    if(_locatorInfo)
+    if (_locatorInfo)
     {
         PropertyDict locatorProperties = _locatorInfo->getLocator()->_getReference()->toProperty(prefix + ".Locator");
-        for(PropertyDict::const_iterator p = locatorProperties.begin(); p != locatorProperties.end(); ++p)
+        for (const auto& locatorProp : locatorProperties)
         {
-            properties[p->first] = p->second;
+            properties[locatorProp.first] = locatorProp.second;
         }
     }
 
+    properties.emplace(std::move(prefix), toString());
+
     return properties;
 }
 
-int
-IceInternal::RoutableReference::hashInit() const
+size_t
+IceInternal::RoutableReference::hash() const noexcept
 {
-    int value = Reference::hashInit();
-    hashAdd(value, _adapterId);
-    return value;
+    size_t h = Reference::hash();
+    hashAdd(h, _adapterId);
+    hashAdd(h, _endpoints);
+    return h;
 }
 
 bool
-IceInternal::RoutableReference::operator==(const Reference& r) const
+IceInternal::RoutableReference::operator==(const Reference& r) const noexcept
 {
     //
     // Note: if(this == &r) test is performed by each non-abstract derived class.
     //
-    if(this == &r)
+    if (this == &r)
     {
         return true;
     }
 
-    const RoutableReference* rhs = dynamic_cast<const RoutableReference*>(&r);
-    if(!rhs || !Reference::operator==(r))
-    {
-        return false;
-    }
-    if(_preferSecure != rhs->_preferSecure)
-    {
-        return false;
-    }
-    if(_collocationOptimized != rhs->_collocationOptimized)
+    const auto* rhs = dynamic_cast<const RoutableReference*>(&r);
+    if (!rhs || !Reference::operator==(r))
     {
         return false;
     }
-    if(_cacheConnection != rhs->_cacheConnection)
+    if (_collocationOptimized != rhs->_collocationOptimized)
     {
         return false;
     }
-    if(_endpointSelection != rhs->_endpointSelection)
+    if (_cacheConnection != rhs->_cacheConnection)
     {
         return false;
     }
-    if(_connectionId != rhs->_connectionId)
+    if (_endpointSelection != rhs->_endpointSelection)
     {
         return false;
     }
-    if((_overrideTimeout != rhs->_overrideTimeout) || (_overrideTimeout && _timeout != rhs->_timeout))
+    if (_connectionId != rhs->_connectionId)
     {
         return false;
     }
-    if(_routerInfo != rhs->_routerInfo)
+    if (!Ice::targetEqualTo(_routerInfo, rhs->_routerInfo))
     {
         return false;
     }
-    if(_locatorInfo != rhs->_locatorInfo)
+    if (!Ice::targetEqualTo(_locatorInfo, rhs->_locatorInfo))
     {
         return false;
     }
-#ifdef ICE_CPP11_MAPPING
-    //
-    // TODO: With C++14 we could use the version that receives four iterators and we don't need to explicitly
-    // check the sizes are equal.
-    //
-    if(_endpoints.size() != rhs->_endpoints.size() ||
-       !equal(_endpoints.begin(), _endpoints.end(), rhs->_endpoints.begin(), Ice::TargetCompare<shared_ptr<EndpointI>, std::equal_to>()))
-#else
-    if(_endpoints != rhs->_endpoints)
-#endif
+
+    // Check if the two endpoint lists are equal.
+    if (!equal(
+            _endpoints.begin(),
+            _endpoints.end(),
+            rhs->_endpoints.begin(),
+            rhs->_endpoints.end(),
+            Ice::TargetCompare<shared_ptr<EndpointI>, std::equal_to>()))
     {
         return false;
     }
-    if(_adapterId != rhs->_adapterId)
+    if (_adapterId != rhs->_adapterId)
     {
         return false;
     }
-    if(_locatorCacheTimeout != rhs->_locatorCacheTimeout)
+    if (_locatorCacheTimeout != rhs->_locatorCacheTimeout)
     {
         return false;
     }
@@ -1401,130 +1112,103 @@ IceInternal::RoutableReference::operator==(const Reference& r) const
 }
 
 bool
-IceInternal::RoutableReference::operator<(const Reference& r) const
+IceInternal::RoutableReference::operator<(const Reference& r) const noexcept
 {
-    if(this == &r)
+    if (this == &r)
     {
         return false;
     }
 
-    if(Reference::operator<(r))
+    if (Reference::operator<(r))
     {
         return true;
     }
-    else if(!Reference::operator==(r))
+    else if (!Reference::operator==(r))
     {
         return false;
     }
 
-    const RoutableReference* rhs = dynamic_cast<const RoutableReference*>(&r);
-    if(!rhs)
+    const auto* rhs = dynamic_cast<const RoutableReference*>(&r);
+    if (!rhs)
     {
         assert(dynamic_cast<const FixedReference*>(&r));
         return true; // As a rule, routable references are superior to fixed references.
     }
 
-    if(!_preferSecure && rhs->_preferSecure)
-    {
-        return true;
-    }
-    else if(rhs->_preferSecure < _preferSecure)
-    {
-        return false;
-    }
-    if(!_collocationOptimized && rhs->_collocationOptimized)
-    {
-        return true;
-    }
-    else if(rhs->_collocationOptimized < _collocationOptimized)
-    {
-        return false;
-    }
-    if(!_cacheConnection && rhs->_cacheConnection)
+    if (!_collocationOptimized && rhs->_collocationOptimized)
     {
         return true;
     }
-    else if(rhs->_cacheConnection < _cacheConnection)
+    else if (rhs->_collocationOptimized < _collocationOptimized)
     {
         return false;
     }
-    if(_endpointSelection < rhs->_endpointSelection)
+    if (!_cacheConnection && rhs->_cacheConnection)
     {
         return true;
     }
-    else if(rhs->_endpointSelection < _endpointSelection)
+    else if (rhs->_cacheConnection < _cacheConnection)
     {
         return false;
     }
-    if(_connectionId < rhs->_connectionId)
+    if (_endpointSelection < rhs->_endpointSelection)
     {
         return true;
     }
-    else if(rhs->_connectionId < _connectionId)
+    else if (rhs->_endpointSelection < _endpointSelection)
     {
         return false;
     }
-    if(!_overrideTimeout && rhs->_overrideTimeout)
+    if (_connectionId < rhs->_connectionId)
     {
         return true;
     }
-    else if(rhs->_overrideTimeout < _overrideTimeout)
+    else if (rhs->_connectionId < _connectionId)
     {
         return false;
     }
-    else if(_overrideTimeout)
-    {
-        if(_timeout < rhs->_timeout)
-        {
-            return true;
-        }
-        else if(rhs->_timeout < _timeout)
-        {
-            return false;
-        }
-    }
-    if(_routerInfo < rhs->_routerInfo)
+    if (Ice::targetLess(_routerInfo, rhs->_routerInfo))
     {
         return true;
     }
-    else if(rhs->_routerInfo < _routerInfo)
+    else if (Ice::targetLess(rhs->_routerInfo, _routerInfo))
     {
         return false;
     }
-    if(_locatorInfo < rhs->_locatorInfo)
+    if (Ice::targetLess(_locatorInfo, rhs->_locatorInfo))
     {
         return true;
     }
-    else if(rhs->_locatorInfo < _locatorInfo)
+    else if (Ice::targetLess(rhs->_locatorInfo, _locatorInfo))
     {
         return false;
     }
-    if(_adapterId < rhs->_adapterId)
+    if (_adapterId < rhs->_adapterId)
     {
         return true;
     }
-    else if(rhs->_adapterId < _adapterId)
+    else if (rhs->_adapterId < _adapterId)
     {
         return false;
     }
-#ifdef ICE_CPP11_MAPPING
-    if(lexicographical_compare(_endpoints.begin(), _endpoints.end(), rhs->_endpoints.begin(), rhs->_endpoints.end(),
-                               Ice::TargetCompare<shared_ptr<EndpointI>, std::less>()))
-#else
-    if(_endpoints < rhs->_endpoints)
-#endif
+    if (lexicographical_compare(
+            _endpoints.begin(),
+            _endpoints.end(),
+            rhs->_endpoints.begin(),
+            rhs->_endpoints.end(),
+            Ice::TargetCompare<shared_ptr<EndpointI>, std::less>()))
     {
         return true;
     }
-    else if(rhs->_endpoints < _endpoints)
+    else if (rhs->_endpoints < _endpoints)
     {
         return false;
     }
-    if(_locatorCacheTimeout < rhs->_locatorCacheTimeout)
+    if (_locatorCacheTimeout < rhs->_locatorCacheTimeout)
     {
         return true;
     }
-    else if(rhs->_locatorCacheTimeout < _locatorCacheTimeout)
+    else if (rhs->_locatorCacheTimeout < _locatorCacheTimeout)
     {
         return false;
     }
@@ -1534,368 +1218,299 @@ IceInternal::RoutableReference::operator<(const Reference& r) const
 ReferencePtr
 IceInternal::RoutableReference::clone() const
 {
-    return new RoutableReference(*this);
+    return make_shared<RoutableReference>(*this);
 }
 
 RequestHandlerPtr
-IceInternal::RoutableReference::getRequestHandler(const Ice::ObjectPrxPtr& proxy) const
+IceInternal::RoutableReference::getRequestHandler() const
 {
-    return getInstance()->requestHandlerFactory()->getRequestHandler(const_cast<RoutableReference*>(this), proxy);
+    auto self = const_cast<RoutableReference*>(this)->shared_from_this();
+
+    if (_collocationOptimized)
+    {
+        Ice::ObjectAdapterPtr adapter = _instance->objectAdapterFactory()->findObjectAdapter(self);
+        if (adapter)
+        {
+            return make_shared<CollocatedRequestHandler>(self, adapter);
+        }
+    }
+
+    ConnectRequestHandlerPtr handler = make_shared<ConnectRequestHandler>(self);
+    getConnectionAsync(
+        [handler](Ice::ConnectionIPtr connection, bool compress)
+        { handler->setConnection(std::move(connection), compress); },
+        [handler](exception_ptr ex) { handler->setException(ex); });
+
+    return handler; // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
+    // Looks like a clang-tidy bug. See https://github.com/llvm/llvm-project/issues/55219
 }
 
-BatchRequestQueuePtr
-IceInternal::RoutableReference::getBatchRequestQueue() const
+const BatchRequestQueuePtr&
+IceInternal::RoutableReference::getBatchRequestQueue() const noexcept
 {
-    return new BatchRequestQueue(getInstance(), getMode() == Reference::ModeBatchDatagram);
+    return _batchRequestQueue;
 }
 
 void
-IceInternal::RoutableReference::getConnection(const GetConnectionCallbackPtr& callback) const
+IceInternal::RoutableReference::getConnectionAsync(
+    function<void(ConnectionIPtr, bool)> response,
+    function<void(std::exception_ptr)> exception) const
 {
-    class Callback : public RouterInfo::GetClientEndpointsCallback
+    if (_routerInfo)
     {
-    public:
+        // If we route, we send everything to the router's client proxy endpoints.
+        auto self = dynamic_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
 
-        virtual void
-        setEndpoints(const vector<EndpointIPtr>& endpoints)
-        {
-            vector<EndpointIPtr> endpts = endpoints;
-            if(!endpts.empty())
+        _routerInfo->getClientEndpointsAsync(
+            [self = std::move(self), response = std::move(response), exception](vector<EndpointIPtr> endpoints) mutable
             {
-                _reference->applyOverrides(endpts);
-                _reference->createConnection(endpts, _callback);
-                return;
-            }
-
-            _reference->getConnectionNoRouterInfo(_callback);
-        }
-
-        virtual void
-        setException(const Ice::LocalException& ex)
-        {
-            _callback->setException(ex);
-        }
-
-        Callback(const RoutableReferencePtr& reference, const GetConnectionCallbackPtr& callback) :
-            _reference(reference), _callback(callback)
-        {
-        }
-
-    private:
-
-        const RoutableReferencePtr _reference;
-        const GetConnectionCallbackPtr _callback;
-    };
-
-    if(_routerInfo)
+                if (endpoints.empty())
+                {
+                    self->getConnectionNoRouterInfoAsync(std::move(response), std::move(exception));
+                }
+                else
+                {
+                    self->applyOverrides(endpoints);
+                    self->createConnectionAsync(endpoints, std::move(response), std::move(exception));
+                }
+            },
+            exception);
+    }
+    else
     {
-        //
-        // If we route, we send everything to the router's client
-        // proxy endpoints.
-        //
-        _routerInfo->getClientEndpoints(new Callback(const_cast<RoutableReference*>(this), callback));
-        return;
+        getConnectionNoRouterInfoAsync(std::move(response), std::move(exception));
     }
-
-    getConnectionNoRouterInfo(callback);
 }
 
 void
-IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCallbackPtr& callback) const
+IceInternal::RoutableReference::getConnectionNoRouterInfoAsync(
+    function<void(ConnectionIPtr, bool)> response,
+    function<void(std::exception_ptr)> exception) const
 {
-    class Callback : public LocatorInfo::GetEndpointsCallback
+    class Callback final : public LocatorInfo::GetEndpointsCallback
     {
     public:
-
-        class Callback2 ICE_FINAL : public Reference::GetConnectionCallback
+        void setEndpoints(const vector<EndpointIPtr>& endpoints, bool cached) final
         {
-        public:
-
-            virtual void
-            setConnection(const Ice::ConnectionIPtr& connection, bool compress)
+            if (endpoints.empty())
             {
-                _callback->setConnection(connection, compress);
+                _exception(make_exception_ptr(
+                    Ice::NoEndpointException(__FILE__, __LINE__, ObjectPrx::_fromReference(_reference))));
+                return;
             }
 
-            virtual void
-            setException(const Ice::LocalException& exc)
-            {
-                try
-                {
-                    exc.ice_throw();
-                }
-                catch(const Ice::NoEndpointException& ex)
-                {
-                    _callback->setException(ex); // No need to retry if there's no endpoints.
-                }
-                catch(const Ice::LocalException& ex)
+            vector<EndpointIPtr> endpts = endpoints;
+            _reference->applyOverrides(endpts);
+            _reference->createConnectionAsync(
+                endpts,
+                _response,
+                [reference = _reference, response = _response, exception = _exception, cached](std::exception_ptr exc)
                 {
-                    LocatorInfoPtr locatorInfo = _reference->getLocatorInfo();
-                    assert(locatorInfo);
-                    locatorInfo->clearCache(_reference);
-                    if(_cached)
+                    try
                     {
-                        TraceLevelsPtr traceLvls = _reference->getInstance()->traceLevels();
-                        if(traceLvls->retry >= 2)
+                        rethrow_exception(exc);
+                    }
+                    catch (const Ice::NoEndpointException&)
+                    {
+                        exception(exc); // No need to retry if there's no endpoints.
+                    }
+                    catch (const Ice::LocalException& ex)
+                    {
+                        LocatorInfoPtr locatorInfo = reference->getLocatorInfo();
+                        assert(locatorInfo);
+                        locatorInfo->clearCache(reference);
+                        if (cached)
                         {
-                            Trace out(_reference->getInstance()->initializationData().logger, traceLvls->retryCat);
-                            out << "connection to cached endpoints failed\n"
-                                << "removing endpoints from cache and trying again\n" << ex;
+                            TraceLevelsPtr traceLvls = reference->getInstance()->traceLevels();
+                            if (traceLvls->retry >= 2)
+                            {
+                                Trace out(reference->getInstance()->initializationData().logger, traceLvls->retryCat);
+                                out << "connection to cached endpoints failed\n"
+                                    << "removing endpoints from cache and trying again\n"
+                                    << ex;
+                            }
+                            reference->getConnectionNoRouterInfoAsync(response, exception); // Retry.
+                            return;
                         }
-                        _reference->getConnectionNoRouterInfo(_callback); // Retry.
-                        return;
+                        exception(exc);
                     }
-                    _callback->setException(ex);
-                }
-            }
-
-            Callback2(const RoutableReferencePtr& reference, const GetConnectionCallbackPtr& cb, bool cached) :
-                _reference(reference), _callback(cb), _cached(cached)
-            {
-            }
-
-        private:
-
-            const RoutableReferencePtr _reference;
-            const GetConnectionCallbackPtr _callback;
-            const bool _cached;
-        };
-
-        virtual void
-        setEndpoints(const vector<EndpointIPtr>& endpoints, bool cached)
-        {
-            if(endpoints.empty())
-            {
-                _callback->setException(Ice::NoEndpointException(__FILE__, __LINE__, _reference->toString()));
-                return;
-            }
-
-            vector<EndpointIPtr> endpts = endpoints;
-            _reference->applyOverrides(endpts);
-            _reference->createConnection(endpts, ICE_MAKE_SHARED(Callback2, _reference, _callback, cached));
+                });
         }
 
-        virtual void
-        setException(const Ice::LocalException& ex)
-        {
-            _callback->setException(ex);
-        }
+        void setException(std::exception_ptr ex) final { _exception(ex); }
 
-        Callback(const RoutableReferencePtr& reference, const GetConnectionCallbackPtr& callback) :
-            _reference(reference), _callback(callback)
+        Callback(
+            RoutableReferencePtr reference,
+            function<void(ConnectionIPtr, bool)> response,
+            function<void(std::exception_ptr)> exception)
+            : _reference(std::move(reference)),
+              _response(std::move(response)),
+              _exception(std::move(exception))
         {
         }
 
     private:
-
         const RoutableReferencePtr _reference;
-        const GetConnectionCallbackPtr _callback;
+        const function<void(ConnectionIPtr, bool)> _response;
+        const function<void(std::exception_ptr)> _exception;
     };
 
-    if(!_endpoints.empty())
+    if (!_endpoints.empty())
     {
-        createConnection(_endpoints, callback);
+        createConnectionAsync(_endpoints, std::move(response), std::move(exception));
         return;
     }
 
-    if(_locatorInfo)
+    if (_locatorInfo)
     {
-        RoutableReference* self = const_cast<RoutableReference*>(this);
-        _locatorInfo->getEndpoints(self, _locatorCacheTimeout, new Callback(self, callback));
+        RoutableReferencePtr self =
+            dynamic_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
+        _locatorInfo->getEndpoints(
+            self,
+            _locatorCacheTimeout,
+            make_shared<Callback>(self, std::move(response), std::move(exception)));
     }
     else
     {
-        callback->setException(Ice::NoEndpointException(__FILE__, __LINE__, toString()));
+        exception(make_exception_ptr(Ice::NoEndpointException(
+            __FILE__,
+            __LINE__,
+            ObjectPrx::_fromReference(const_cast<RoutableReference*>(this)->shared_from_this()))));
     }
 }
 
 void
-IceInternal::RoutableReference::createConnection(const vector<EndpointIPtr>& allEndpoints,
-                                                 const GetConnectionCallbackPtr& callback) const
+IceInternal::RoutableReference::createConnectionAsync(
+    const vector<EndpointIPtr>& allEndpoints,
+    function<void(ConnectionIPtr, bool)> response,
+    function<void(std::exception_ptr)> exception) const
 {
     vector<EndpointIPtr> endpoints = filterEndpoints(allEndpoints);
-    if(endpoints.empty())
+    if (endpoints.empty())
     {
-        callback->setException(Ice::NoEndpointException(__FILE__, __LINE__, toString()));
+        exception(make_exception_ptr(Ice::NoEndpointException(
+            __FILE__,
+            __LINE__,
+            ObjectPrx::_fromReference(const_cast<RoutableReference*>(this)->shared_from_this()))));
         return;
     }
 
-    //
-    // Finally, create the connection.
-    //
     OutgoingConnectionFactoryPtr factory = getInstance()->outgoingConnectionFactory();
-    if(getCacheConnection() || endpoints.size() == 1)
+    auto self = static_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
+
+    auto createConnectionSucceded =
+        [routerInfo = _routerInfo, response = std::move(response)](Ice::ConnectionIPtr connection, bool compress)
     {
-        class CB1 : public OutgoingConnectionFactory::CreateConnectionCallback
+        // If we have a router, set the object adapter for this router (if any) to the new connection, so that
+        // callbacks from the router can be received over this new connection.
+        if (routerInfo && routerInfo->getAdapter())
         {
-        public:
-
-            virtual void
-            setConnection(const Ice::ConnectionIPtr& connection, bool compress)
-            {
-                //
-                // If we have a router, set the object adapter for this router
-                // (if any) to the new connection, so that callbacks from the
-                // router can be received over this new connection.
-                //
-                if(_routerInfo && _routerInfo->getAdapter())
-                {
-                    connection->setAdapter(_routerInfo->getAdapter());
-                }
-                _callback->setConnection(connection, compress);
-            }
-
-            virtual void
-            setException(const Ice::LocalException& ex)
-            {
-                _callback->setException(ex);
-            }
-
-            CB1(const RouterInfoPtr& routerInfo, const GetConnectionCallbackPtr& callback) :
-                _routerInfo(routerInfo), _callback(callback)
-            {
-            }
-
-        private:
-
-            const RouterInfoPtr _routerInfo;
-            const GetConnectionCallbackPtr _callback;
-        };
+            connection->setAdapter(routerInfo->getAdapter());
+        }
+        response(std::move(connection), compress);
+    };
 
-        //
-        // Get an existing connection or create one if there's no
-        // existing connection to one of the given endpoints.
-        //
-        factory->create(endpoints, false, getEndpointSelection(), new CB1(_routerInfo, callback));
-        return;
+    if (getCacheConnection() || endpoints.size() == 1)
+    {
+        // Get an existing connection or create one if there's no existing connection to one of the given endpoints.
+        factory->createAsync(std::move(endpoints), false, std::move(createConnectionSucceded), std::move(exception));
     }
     else
     {
-        class CB2 : public OutgoingConnectionFactory::CreateConnectionCallback
+        // Go through the list of endpoints and try to create the connection until it succeeds. This is different from
+        // just calling create() with the given endpoints since this might create a new connection even if there's an
+        // existing connection for one of the endpoints.
+
+        class CreateConnectionState final : public std::enable_shared_from_this<CreateConnectionState>
         {
         public:
+            CreateConnectionState(
+                vector<EndpointIPtr> endpoints,
+                OutgoingConnectionFactoryPtr factory,
+                function<void(Ice::ConnectionIPtr, bool)> createConnectionSucceded,
+                function<void(exception_ptr)> exception)
+                : _endpoints(std::move(endpoints)),
+                  _factory(std::move(factory)),
+                  _createConnectionSucceded(std::move(createConnectionSucceded)),
+                  _createConnectionFailed(std::move(exception))
+            {
+            }
 
-            virtual void
-            setConnection(const Ice::ConnectionIPtr& connection, bool compress)
+            void createAsync()
             {
-                //
-                // If we have a router, set the object adapter for this router
-                // (if any) to the new connection, so that callbacks from the
-                // router can be received over this new connection.
-                //
-                if(_reference->getRouterInfo() && _reference->getRouterInfo()->getAdapter())
-                {
-                    connection->setAdapter(_reference->getRouterInfo()->getAdapter());
-                }
-                _callback->setConnection(connection, compress);
+                _factory->createAsync(
+                    {_endpoints[_endpointIndex]},
+                    true,
+                    _createConnectionSucceded,
+                    [self = shared_from_this()](exception_ptr e) { self->handleException(e); });
             }
 
-            virtual void
-            setException(const Ice::LocalException& ex)
+            void handleException(std::exception_ptr ex)
             {
-                if(!_exception)
+                if (!_exception)
                 {
-                    ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone());
+                    _exception = ex;
                 }
 
-                if(++_i == _endpoints.size())
+                if (++_endpointIndex == _endpoints.size())
                 {
-                    _callback->setException(*_exception);
+                    _createConnectionFailed(_exception);
                     return;
                 }
 
-                const bool more = _i != _endpoints.size() - 1;
-                vector<EndpointIPtr> endpoint;
-                endpoint.push_back(_endpoints[_i]);
-
-                OutgoingConnectionFactoryPtr factory = _reference->getInstance()->outgoingConnectionFactory();
-                factory->create(endpoint, more, _reference->getEndpointSelection(), this);
-            }
-
-            CB2(const RoutableReferencePtr& reference, const vector<EndpointIPtr>& endpoints,
-                const GetConnectionCallbackPtr& callback) :
-                _reference(reference),
-                _endpoints(endpoints),
-                _callback(callback),
-                _i(0)
-            {
+                const bool more = _endpointIndex != _endpoints.size() - 1;
+                _factory->createAsync(
+                    {_endpoints[_endpointIndex]},
+                    more,
+                    _createConnectionSucceded,
+                    [self = shared_from_this()](exception_ptr e) { self->handleException(e); });
             }
 
         private:
-
-            const RoutableReferencePtr _reference;
-            const vector<EndpointIPtr> _endpoints;
-            const GetConnectionCallbackPtr _callback;
-            size_t _i;
-            IceInternal::UniquePtr<Ice::LocalException> _exception;
+            exception_ptr _exception = nullptr;
+            size_t _endpointIndex = 0;
+            vector<EndpointIPtr> _endpoints;
+            OutgoingConnectionFactoryPtr _factory;
+            std::function<void(Ice::ConnectionIPtr, bool)> _createConnectionSucceded;
+            std::function<void(exception_ptr)> _createConnectionFailed;
         };
 
-        //
-        // Go through the list of endpoints and try to create the
-        // connection until it succeeds. This is different from just
-        // calling create() with the given endpoints since this might
-        // create a new connection even if there's an existing
-        // connection for one of the endpoints.
-        //
-
-        vector<EndpointIPtr> endpt;
-        endpt.push_back(endpoints[0]);
-        RoutableReference* self = const_cast<RoutableReference*>(this);
-        factory->create(endpt, true, getEndpointSelection(), new CB2(self, endpoints, callback));
-        return;
+        auto state = make_shared<CreateConnectionState>(
+            std::move(endpoints),
+            std::move(factory),
+            std::move(createConnectionSucceded),
+            std::move(exception));
+        state->createAsync();
     }
 }
 
 void
 IceInternal::RoutableReference::applyOverrides(vector<EndpointIPtr>& endpoints) const
 {
-    for(vector<EndpointIPtr>::iterator p = endpoints.begin(); p != endpoints.end(); ++p)
+    for (auto& endpoint : endpoints)
     {
-        *p = (*p)->connectionId(_connectionId);
-        if(_overrideCompress)
+        endpoint = endpoint->connectionId(_connectionId);
+        optional<bool> compress = getCompress();
+        if (compress.has_value())
         {
-            *p = (*p)->compress(_compress);
-        }
-        if(_overrideTimeout)
-        {
-            *p = (*p)->timeout(_timeout);
+            endpoint = endpoint->compress(*compress);
         }
     }
 }
 
-IceInternal::RoutableReference::RoutableReference(const RoutableReference& r) :
-    Reference(r),
-    _endpoints(r._endpoints),
-    _adapterId(r._adapterId),
-    _locatorInfo(r._locatorInfo),
-    _routerInfo(r._routerInfo),
-    _collocationOptimized(r._collocationOptimized),
-    _cacheConnection(r._cacheConnection),
-    _preferSecure(r._preferSecure),
-    _endpointSelection(r._endpointSelection),
-    _locatorCacheTimeout(r._locatorCacheTimeout),
-    _overrideTimeout(r._overrideTimeout),
-    _timeout(r._timeout),
-    _connectionId(r._connectionId)
+IceInternal::RoutableReference::RoutableReference(const RoutableReference& r)
+    : Reference(r),
+      _endpoints(r._endpoints),
+      _adapterId(r._adapterId),
+      _locatorInfo(r._locatorInfo),
+      _routerInfo(r._routerInfo),
+      _collocationOptimized(r._collocationOptimized),
+      _cacheConnection(r._cacheConnection),
+      _endpointSelection(r._endpointSelection),
+      _locatorCacheTimeout(r._locatorCacheTimeout),
+      _connectionId(r._connectionId)
 {
-}
-
-namespace
-{
-
-#ifndef ICE_CPP11_COMPILER
-struct EndpointIsOpaque : public unary_function<EndpointIPtr, bool>
-{
-public:
-
-    bool
-    operator()(EndpointIPtr p) const
-    {
-        return dynamic_cast<OpaqueEndpointI*>(p.get()) != 0;
-    }
-};
-#endif
-
+    setBatchRequestQueue();
 }
 
 vector<EndpointIPtr>
@@ -1903,63 +1518,35 @@ IceInternal::RoutableReference::filterEndpoints(const vector<EndpointIPtr>& allE
 {
     vector<EndpointIPtr> endpoints = allEndpoints;
 
-    //
     // Filter out unknown endpoints.
-    //
-#ifdef ICE_CPP11_COMPILER
-    endpoints.erase(remove_if(endpoints.begin(), endpoints.end(),
-                              [](const EndpointIPtr& p)
-                              {
-                                  return dynamic_cast<OpaqueEndpointI*>(p.get()) != 0;
-                              }),
-                    endpoints.end());
-#else
-    endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), EndpointIsOpaque()), endpoints.end());
-#endif
-    //
+    endpoints.erase(
+        remove_if(
+            endpoints.begin(),
+            endpoints.end(),
+            [](const EndpointIPtr& p) { return dynamic_pointer_cast<OpaqueEndpointI>(p) != nullptr; }),
+        endpoints.end());
+
     // Filter out endpoints according to the mode of the reference.
-    //
-    switch(getMode())
+    switch (getMode())
     {
         case Reference::ModeTwoway:
         case Reference::ModeOneway:
         case Reference::ModeBatchOneway:
         {
-            //
             // Filter out datagram endpoints.
-            //
-#ifdef ICE_CPP11_COMPILER
-            endpoints.erase(remove_if(endpoints.begin(), endpoints.end(),
-                                      [](const EndpointIPtr& p)
-                                      {
-                                          return p->datagram();
-                                      }),
-                            endpoints.end());
-#else
-            endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), Ice::constMemFun(&EndpointI::datagram)),
-                            endpoints.end());
-#endif
+            endpoints.erase(
+                remove_if(endpoints.begin(), endpoints.end(), [](const EndpointIPtr& p) { return p->datagram(); }),
+                endpoints.end());
             break;
         }
 
         case Reference::ModeDatagram:
         case Reference::ModeBatchDatagram:
         {
-            //
             // Filter out non-datagram endpoints.
-            //
-#ifdef ICE_CPP11_COMPILER
-            endpoints.erase(remove_if(endpoints.begin(), endpoints.end(),
-                                      [](const EndpointIPtr& p)
-                                      {
-                                          return !p->datagram();
-                                      }),
-                            endpoints.end());
-#else
-            endpoints.erase(remove_if(endpoints.begin(), endpoints.end(),
-                                      not1(Ice::constMemFun(&EndpointI::datagram))),
-                            endpoints.end());
-#endif
+            endpoints.erase(
+                remove_if(endpoints.begin(), endpoints.end(), [](const EndpointIPtr& p) { return !p->datagram(); }),
+                endpoints.end());
             break;
         }
     }
@@ -1967,14 +1554,14 @@ IceInternal::RoutableReference::filterEndpoints(const vector<EndpointIPtr>& allE
     //
     // Sort the endpoints according to the endpoint selection type.
     //
-    switch(getEndpointSelection())
+    switch (getEndpointSelection())
     {
-        case ICE_ENUM(EndpointSelectionType, Random):
+        case EndpointSelectionType::Random:
         {
-            IceUtilInternal::shuffle(endpoints.begin(), endpoints.end());
+            IceInternal::shuffle(endpoints.begin(), endpoints.end());
             break;
         }
-        case ICE_ENUM(EndpointSelectionType, Ordered):
+        case EndpointSelectionType::Ordered:
         {
             // Nothing to do.
             break;
@@ -1986,61 +1573,12 @@ IceInternal::RoutableReference::filterEndpoints(const vector<EndpointIPtr>& allE
         }
     }
 
-    //
-    // If a secure connection is requested or secure overrides is set,
-    // remove all non-secure endpoints. Otherwise if preferSecure is set
-    // make secure endpoints prefered. By default make non-secure
-    // endpoints preferred over secure endpoints.
-    //
-    DefaultsAndOverridesPtr overrides = getInstance()->defaultsAndOverrides();
-    if(overrides->overrideSecure ? overrides->overrideSecureValue : getSecure())
-    {
-#ifdef ICE_CPP11_COMPILER
-        endpoints.erase(remove_if(endpoints.begin(), endpoints.end(),
-                                  [](const EndpointIPtr& p)
-                                  {
-                                      return !p->secure();
-                                  }),
-                        endpoints.end());
-#else
-        endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), not1(Ice::constMemFun(&EndpointI::secure))),
-                        endpoints.end());
-#endif
-    }
-    else if(getPreferSecure())
-    {
-        //
-        // We must use stable_partition() instead of just simply
-        // partition(), because otherwise some STL implementations
-        // order our now randomized endpoints.
-        //
-#ifdef ICE_CPP11_COMPILER
-        stable_partition(endpoints.begin(), endpoints.end(),
-                         [](const EndpointIPtr& p)
-                         {
-                             return p->secure();
-                         });
-#else
-        stable_partition(endpoints.begin(), endpoints.end(), Ice::constMemFun(&EndpointI::secure));
-#endif
-    }
-    else
-    {
-        //
-        // We must use stable_partition() instead of just simply
-        // partition(), because otherwise some STL implementations
-        // order our now randomized endpoints.
-        //
-#ifdef ICE_CPP11_COMPILER
-        stable_partition(endpoints.begin(), endpoints.end(),
-                         [](const EndpointIPtr& p)
-                         {
-                             return !p->secure();
-                         });
-#else
-        stable_partition(endpoints.begin(), endpoints.end(), not1(Ice::constMemFun(&EndpointI::secure)));
-#endif
-    }
-
     return endpoints;
 }
+
+void
+IceInternal::RoutableReference::setBatchRequestQueue()
+{
+    _batchRequestQueue =
+        isBatch() ? make_shared<BatchRequestQueue>(getInstance(), getMode() == Reference::ModeBatchDatagram) : nullptr;
+}