zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/ProxyFactory.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <IceUtil/Thread.h>
 #include <IceUtil/Time.h>
@@ -15,7 +10,8 @@
 #include <Ice/ReferenceFactory.h>
 #include <Ice/LocatorInfo.h>
 #include <Ice/RouterInfo.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/Properties.h>
 #include <Ice/LoggerUtil.h>
 #include <Ice/TraceLevels.h>
@@ -28,7 +24,7 @@ using namespace IceInternal;
 
 IceUtil::Shared* IceInternal::upCast(ProxyFactory* p) { return p; }
 
-ObjectPrx
+ObjectPrxPtr
 IceInternal::ProxyFactory::stringToProxy(const string& str) const
 {
     ReferencePtr ref = _instance->referenceFactory()->create(str, "");
@@ -36,11 +32,11 @@ IceInternal::ProxyFactory::stringToProxy(const string& str) const
 }
 
 string
-IceInternal::ProxyFactory::proxyToString(const ObjectPrx& proxy) const
+IceInternal::ProxyFactory::proxyToString(const ObjectPrxPtr& proxy) const
 {
     if(proxy)
     {
-        return proxy->__reference()->toString();
+        return proxy->_getReference()->toString();
     }
     else
     {
@@ -48,7 +44,7 @@ IceInternal::ProxyFactory::proxyToString(const ObjectPrx& proxy) const
     }
 }
 
-ObjectPrx
+ObjectPrxPtr
 IceInternal::ProxyFactory::propertyToProxy(const string& prefix) const
 {
     string proxy = _instance->initializationData().properties->getProperty(prefix);
@@ -57,11 +53,11 @@ IceInternal::ProxyFactory::propertyToProxy(const string& prefix) const
 }
 
 PropertyDict
-IceInternal::ProxyFactory::proxyToProperty(const ObjectPrx& proxy, const string& prefix) const
+IceInternal::ProxyFactory::proxyToProperty(const ObjectPrxPtr& proxy, const string& prefix) const
 {
     if(proxy)
     {
-        return proxy->__reference()->toProperty(prefix);
+        return proxy->_getReference()->toProperty(prefix);
     }
     else
     {
@@ -69,8 +65,8 @@ IceInternal::ProxyFactory::proxyToProperty(const ObjectPrx& proxy, const string&
     }
 }
 
-ObjectPrx
-IceInternal::ProxyFactory::streamToProxy(BasicStream* s) const
+ObjectPrxPtr
+IceInternal::ProxyFactory::streamToProxy(InputStream* s) const
 {
     Identity ident;
     s->read(ident);
@@ -79,33 +75,22 @@ IceInternal::ProxyFactory::streamToProxy(BasicStream* s) const
     return referenceToProxy(ref);
 }
 
-void
-IceInternal::ProxyFactory::proxyToStream(const ObjectPrx& proxy, BasicStream* s) const
-{
-    if(proxy)
-    {
-        s->write(proxy->__reference()->getIdentity());
-        proxy->__reference()->streamWrite(s);
-    }
-    else
-    {
-        Identity ident;
-        s->write(ident);
-    }
-}
-
-ObjectPrx
+ObjectPrxPtr
 IceInternal::ProxyFactory::referenceToProxy(const ReferencePtr& ref) const
 {
     if(ref)
     {
-        ObjectPrx proxy = new ::IceProxy::Ice::Object;
+#ifdef ICE_CPP11_MAPPING
+        auto proxy = createProxy<ObjectPrx>();
+#else
+        ObjectPrx proxy = new ::IceProxy::Ice::Object();
+#endif
         proxy->setup(ref);
         return proxy;
     }
     else
     {
-        return 0;
+        return ICE_NULLPTR;
     }
 }
 
@@ -125,6 +110,15 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co
         ex.ice_throw();
     }
 
+    //
+    // If it's a fixed proxy, retrying isn't useful as the proxy is tied to
+    // the connection and the request will fail with the exception.
+    //
+    if(dynamic_cast<const FixedReference*>(ref.get()))
+    {
+        ex.ice_throw();
+    }
+
     const ObjectNotExistException* one = dynamic_cast<const ObjectNotExistException*>(&ex);
     if(one)
     {
@@ -211,11 +205,12 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co
     }
 
     //
-    // Don't retry if the communicator is destroyed or object adapter
-    // deactivated.
+    // Don't retry if the communicator is destroyed, object adapter is deactivated,
+    // or connection is manually closed.
     //
     if(dynamic_cast<const CommunicatorDestroyedException*>(&ex) ||
-       dynamic_cast<const ObjectAdapterDeactivatedException*>(&ex))
+       dynamic_cast<const ObjectAdapterDeactivatedException*>(&ex) ||
+       dynamic_cast<const ConnectionManuallyClosedException*>(&ex))
     {
         ex.ice_throw();
     }
@@ -239,7 +234,7 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co
         // limit is reached.
         //
         interval = 0;
-    } 
+    }
     else if(cnt > static_cast<int>(_retryIntervals.size()))
     {
         if(traceLevels->retry >= 1)
@@ -251,7 +246,7 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co
     }
     else
     {
-        interval = _retryIntervals[cnt - 1];
+        interval = _retryIntervals[static_cast<size_t>(cnt - 1)];
     }
 
     if(traceLevels->retry >= 1)

data/ext/ice/cpp/src/Ice/ProxyFactory.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_PROXY_FACTORY_H
 #define ICE_PROXY_FACTORY_H
@@ -20,25 +15,30 @@
 #include <Ice/OutgoingAsyncF.h>
 #include <Ice/Properties.h>
 
-namespace IceInternal
+namespace Ice
 {
 
-class BasicStream;
+class OutputStream;
+class InputStream;
+
+}
+
+namespace IceInternal
+{
 
 class ProxyFactory : public IceUtil::Shared
 {
 public:
-    
-    Ice::ObjectPrx stringToProxy(const std::string&) const;
-    std::string proxyToString(const Ice::ObjectPrx&) const;
 
-    Ice::ObjectPrx propertyToProxy(const std::string&) const;
-    Ice::PropertyDict proxyToProperty(const Ice::ObjectPrx&, const std::string&) const;
+    Ice::ObjectPrxPtr stringToProxy(const std::string&) const;
+    std::string proxyToString(const Ice::ObjectPrxPtr&) const;
+
+    Ice::ObjectPrxPtr propertyToProxy(const std::string&) const;
+    Ice::PropertyDict proxyToProperty(const Ice::ObjectPrxPtr&, const std::string&) const;
 
-    Ice::ObjectPrx streamToProxy(BasicStream*) const;
-    void proxyToStream(const Ice::ObjectPrx&, BasicStream*) const;
+    Ice::ObjectPrxPtr streamToProxy(Ice::InputStream*) const;
 
-    Ice::ObjectPrx referenceToProxy(const ReferencePtr&) const;
+    Ice::ObjectPrxPtr referenceToProxy(const ReferencePtr&) const;
 
     int checkRetryAfterException(const Ice::LocalException&, const ReferencePtr&, int&) const;
 

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/Reference.h>
 #include <Ice/ReferenceFactory.h>
@@ -13,7 +8,7 @@
 #include <Ice/Instance.h>
 #include <Ice/EndpointI.h>
 #include <Ice/OpaqueEndpointI.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
 #include <Ice/RouterInfo.h>
 #include <Ice/Router.h>
 #include <Ice/LocatorInfo.h>
@@ -27,11 +22,14 @@
 #include <Ice/RequestHandlerFactory.h>
 #include <Ice/ConnectionRequestHandler.h>
 #include <Ice/DefaultsAndOverrides.h>
-#include <IceUtil/StringUtil.h>
+#include <Ice/Comparable.h>
+#include <Ice/StringUtil.h>
+
 #include <IceUtil/Random.h>
 #include <IceUtil/MutexPtrLock.h>
 
 #include <functional>
+#include <algorithm>
 
 using namespace std;
 using namespace Ice;
@@ -62,14 +60,6 @@ public:
 
 Init init;
 
-struct RandomNumberGenerator : public std::unary_function<ptrdiff_t, ptrdiff_t>
-{
-    ptrdiff_t operator()(ptrdiff_t d)
-    {
-        return IceUtilInternal::random(static_cast<int>(d));
-    }
-};
-
 }
 
 CommunicatorPtr
@@ -171,6 +161,25 @@ IceInternal::Reference::changeCompress(bool newCompress) const
     return r;
 }
 
+bool
+IceInternal::Reference::getCompressOverride(bool& compress) const
+{
+    DefaultsAndOverridesPtr defaultsAndOverrides = getInstance()->defaultsAndOverrides();
+    if(defaultsAndOverrides->overrideCompress)
+    {
+        compress = defaultsAndOverrides->overrideCompressValue;
+    }
+    else if(_overrideCompress)
+    {
+        compress = _compress;
+    }
+    else
+    {
+        return false;
+    }
+    return true;
+}
+
 Int
 Reference::hash() const
 {
@@ -184,7 +193,7 @@ Reference::hash() const
 }
 
 void
-IceInternal::Reference::streamWrite(BasicStream* s) const
+IceInternal::Reference::streamWrite(OutputStream* s) const
 {
     //
     // Don't write the identity here. Operations calling streamWrite
@@ -207,7 +216,7 @@ IceInternal::Reference::streamWrite(BasicStream* s) const
 
     s->write(_secure);
 
-    if(s->getWriteEncoding() != Ice::Encoding_1_0)
+    if(s->getEncoding() != Ice::Encoding_1_0)
     {
         s->write(_protocol);
         s->write(_encoding);
@@ -228,13 +237,18 @@ IceInternal::Reference::toString() const
     //
     ostringstream s;
 
+    ToStringMode toStringMode = _instance->toStringMode();
+    const string separators = " :@";
+
+    string id = Ice::identityToString(_identity, toStringMode);
+
     //
     // If the encoded identity string contains characters which
     // the reference parser uses as separators, then we enclose
     // the identity string in quotes.
     //
-    string id = _instance->identityToString(_identity);
-    if(id.find_first_of(" :@") != string::npos)
+
+    if(id.find_first_of(separators) != string::npos)
     {
         s << '"' << id << '"';
     }
@@ -247,14 +261,13 @@ IceInternal::Reference::toString() const
     {
         s << " -f ";
 
+        string fs = escapeString(_facet, "", toStringMode);
         //
         // If the encoded facet string contains characters which
         // the reference parser uses as separators, then we enclose
         // the facet string in quotes.
         //
-        string fs = nativeToUTF8(_facet, _instance->getStringConverter());
-        fs = IceUtilInternal::escapeString(fs, "");
-        if(fs.find_first_of(" :@") != string::npos)
+        if(fs.find_first_of(separators) != string::npos)
         {
             s << '"' << fs << '"';
         }
@@ -376,16 +389,9 @@ IceInternal::Reference::operator==(const Reference& r) const
     {
         return false;
     }
-
     return true;
 }
 
-bool
-IceInternal::Reference::operator!=(const Reference& r) const
-{
-    return !operator==(r);
-}
-
 bool
 IceInternal::Reference::operator<(const Reference& r) const
 {
@@ -488,6 +494,7 @@ IceInternal::Reference::operator<(const Reference& r) const
     return false;
 }
 
+#ifndef ICE_CPP11_COMPILER
 class ConnectionIsDatagram : public unary_function<ConnectionIPtr, bool>
 {
 public:
@@ -509,6 +516,7 @@ public:
         return p->endpoint()->secure();
     }
 };
+#endif
 
 IceInternal::Reference::Reference(const InstancePtr& instance,
                                   const CommunicatorPtr& communicator,
@@ -537,6 +545,7 @@ IceInternal::Reference::Reference(const InstancePtr& instance,
 }
 
 IceInternal::Reference::Reference(const Reference& r) :
+    IceUtil::Shared(),
     _hashInitialized(false),
     _instance(r._instance),
     _communicator(r._communicator),
@@ -584,11 +593,20 @@ IceInternal::FixedReference::FixedReference(const InstancePtr& instance,
                                             const string& facet,
                                             Mode mode,
                                             bool secure,
+                                            const ProtocolVersion& protocol,
                                             const EncodingVersion& encoding,
-                                            const ConnectionIPtr& fixedConnection) :
-    Reference(instance, communicator, id, facet, mode, secure, Ice::Protocol_1_0, encoding, -1, Ice::Context()),
+                                            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>
@@ -624,7 +642,7 @@ IceInternal::FixedReference::getPreferSecure() const
 Ice::EndpointSelectionType
 IceInternal::FixedReference::getEndpointSelection() const
 {
-    return Random;
+    return ICE_ENUM(EndpointSelectionType, Random);
 }
 
 int
@@ -639,81 +657,88 @@ IceInternal::FixedReference::getConnectionId() const
     return string();
 }
 
+IceUtil::Optional<int>
+IceInternal::FixedReference::getTimeout() const
+{
+    return IceUtil::Optional<int>();
+}
+
 ReferencePtr
 IceInternal::FixedReference::changeEndpoints(const vector<EndpointIPtr>& /*newEndpoints*/) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
 IceInternal::FixedReference::changeAdapterId(const string& /*newAdapterId*/) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeLocator(const LocatorPrx&) const
+IceInternal::FixedReference::changeLocator(const LocatorPrxPtr&) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeRouter(const RouterPrx&) const
+IceInternal::FixedReference::changeRouter(const RouterPrxPtr&) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
 IceInternal::FixedReference::changeCollocationOptimized(bool) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
 IceInternal::FixedReference::changeCacheConnection(bool) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
 IceInternal::FixedReference::changePreferSecure(bool) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
 IceInternal::FixedReference::changeEndpointSelection(EndpointSelectionType) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
 IceInternal::FixedReference::changeLocatorCacheTimeout(int) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
 IceInternal::FixedReference::changeTimeout(int) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
 IceInternal::FixedReference::changeConnectionId(const string&) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-    return 0; // Keep the compiler happy.
+}
+
+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;
+    return r;
 }
 
 bool
@@ -729,31 +754,19 @@ IceInternal::FixedReference::isWellKnown() const
 }
 
 void
-IceInternal::FixedReference::streamWrite(BasicStream*) const
-{
-    throw FixedProxyException(__FILE__, __LINE__);
-}
-
-string
-IceInternal::FixedReference::toString() const
+IceInternal::FixedReference::streamWrite(OutputStream*) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-
-    assert(false);   // Cannot be reached.
-    return string(); // To keep the compiler from complaining.
 }
 
 PropertyDict
 IceInternal::FixedReference::toProperty(const string&) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-
-    assert(false);   // Cannot be reached.
-    return PropertyDict(); // To keep the compiler from complaining.
 }
 
 RequestHandlerPtr
-IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrx& proxy) const
+IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrxPtr& proxy) const
 {
     switch(getMode())
     {
@@ -763,7 +776,7 @@ IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrx& proxy) cons
     {
         if(_fixedConnection->endpoint()->datagram())
         {
-            throw NoEndpointException(__FILE__, __LINE__, "");
+            throw NoEndpointException(__FILE__, __LINE__, toString());
         }
         break;
     }
@@ -773,7 +786,7 @@ IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrx& proxy) cons
     {
         if(!_fixedConnection->endpoint()->datagram())
         {
-            throw NoEndpointException(__FILE__, __LINE__, "");
+            throw NoEndpointException(__FILE__, __LINE__, toString());
         }
         break;
     }
@@ -795,12 +808,12 @@ IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrx& proxy) cons
     }
     if(secure && !_fixedConnection->endpoint()->secure())
     {
-        throw NoEndpointException(__FILE__, __LINE__, "");
+        throw NoEndpointException(__FILE__, __LINE__, toString());
     }
 
     _fixedConnection->throwException(); // Throw in case our connection is already destroyed.
 
-    bool compress;
+    bool compress = false;
     if(defaultsAndOverrides->overrideCompress)
     {
         compress = defaultsAndOverrides->overrideCompressValue;
@@ -809,13 +822,9 @@ IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrx& proxy) cons
     {
         compress = _compress;
     }
-    else
-    {
-        compress = _fixedConnection->endpoint()->compress();
-    }
 
     ReferencePtr ref = const_cast<FixedReference*>(this);
-    return proxy->__setRequestHandler(new ConnectionRequestHandler(ref, _fixedConnection, compress));
+    return proxy->_setRequestHandler(ICE_MAKE_SHARED(ConnectionRequestHandler, ref, _fixedConnection, compress));
 }
 
 BatchRequestQueuePtr
@@ -839,12 +848,6 @@ IceInternal::FixedReference::operator==(const Reference& r) const
     return _fixedConnection == rhs->_fixedConnection;
 }
 
-bool
-IceInternal::FixedReference::operator!=(const Reference& r) const
-{
-    return !operator==(r);
-}
-
 bool
 IceInternal::FixedReference::operator<(const Reference& r) const
 {
@@ -979,6 +982,12 @@ IceInternal::RoutableReference::getConnectionId() const
     return _connectionId;
 }
 
+IceUtil::Optional<int>
+IceInternal::RoutableReference::getTimeout() const
+{
+    return _overrideTimeout ? IceUtil::Optional<int>(_timeout) : IceUtil::None;
+}
+
 ReferencePtr
 IceInternal::RoutableReference::changeEncoding(const Ice::EncodingVersion& encoding) const
 {
@@ -1039,7 +1048,7 @@ IceInternal::RoutableReference::changeAdapterId(const string& newAdapterId) cons
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeLocator(const LocatorPrx& newLocator) const
+IceInternal::RoutableReference::changeLocator(const LocatorPrxPtr& newLocator) const
 {
     LocatorInfoPtr newLocatorInfo = getInstance()->locatorManager()->get(newLocator);
     if(newLocatorInfo == _locatorInfo)
@@ -1052,7 +1061,7 @@ IceInternal::RoutableReference::changeLocator(const LocatorPrx& newLocator) cons
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeRouter(const RouterPrx& newRouter) const
+IceInternal::RoutableReference::changeRouter(const RouterPrxPtr& newRouter) const
 {
     RouterInfoPtr newRouterInfo = getInstance()->routerManager()->get(newRouter);
     if(newRouterInfo == _routerInfo)
@@ -1167,6 +1176,23 @@ IceInternal::RoutableReference::changeConnectionId(const string& id) const
     return r;
 }
 
+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());
+}
+
 bool
 IceInternal::RoutableReference::isIndirect() const
 {
@@ -1180,7 +1206,7 @@ IceInternal::RoutableReference::isWellKnown() const
 }
 
 void
-IceInternal::RoutableReference::streamWrite(BasicStream* s) const
+IceInternal::RoutableReference::streamWrite(OutputStream* s) const
 {
     Reference::streamWrite(s);
 
@@ -1234,8 +1260,7 @@ IceInternal::RoutableReference::toString() const
         // reference parser uses as separators, then we enclose the
         // adapter id string in quotes.
         //
-        string a = nativeToUTF8(_adapterId, getInstance()->getStringConverter());
-        a = IceUtilInternal::escapeString(a, "");
+        string a = escapeString(_adapterId, "", getInstance()->toStringMode());
         if(a.find_first_of(" :@") != string::npos)
         {
             result.append("\"");
@@ -1263,7 +1288,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const
     properties[prefix + ".CollocationOptimized"] = _collocationOptimized ? "1" : "0";
     properties[prefix + ".ConnectionCached"] = _cacheConnection ? "1" : "0";
     properties[prefix + ".PreferSecure"] = _preferSecure ? "1" : "0";
-    properties[prefix + ".EndpointSelection"] = _endpointSelection == Random ? "Random" : "Ordered";
+    properties[prefix + ".EndpointSelection"] = _endpointSelection == ICE_ENUM(EndpointSelectionType, Random) ? "Random" : "Ordered";
     {
         ostringstream s;
         s << _locatorCacheTimeout;
@@ -1276,7 +1301,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const
     }
     if(_routerInfo)
     {
-        PropertyDict routerProperties = _routerInfo->getRouter()->__reference()->toProperty(prefix + ".Router");
+        PropertyDict routerProperties = _routerInfo->getRouter()->_getReference()->toProperty(prefix + ".Router");
         for(PropertyDict::const_iterator p = routerProperties.begin(); p != routerProperties.end(); ++p)
         {
             properties[p->first] = p->second;
@@ -1285,7 +1310,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const
 
     if(_locatorInfo)
     {
-        PropertyDict locatorProperties = _locatorInfo->getLocator()->__reference()->toProperty(prefix + ".Locator");
+        PropertyDict locatorProperties = _locatorInfo->getLocator()->_getReference()->toProperty(prefix + ".Locator");
         for(PropertyDict::const_iterator p = locatorProperties.begin(); p != locatorProperties.end(); ++p)
         {
             properties[p->first] = p->second;
@@ -1351,7 +1376,16 @@ IceInternal::RoutableReference::operator==(const Reference& r) const
     {
         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
     {
         return false;
     }
@@ -1366,12 +1400,6 @@ IceInternal::RoutableReference::operator==(const Reference& r) const
     return true;
 }
 
-bool
-IceInternal::RoutableReference::operator!=(const Reference& r) const
-{
-    return !operator==(r);
-}
-
 bool
 IceInternal::RoutableReference::operator<(const Reference& r) const
 {
@@ -1479,7 +1507,12 @@ IceInternal::RoutableReference::operator<(const Reference& r) const
     {
         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
     {
         return true;
     }
@@ -1505,7 +1538,7 @@ IceInternal::RoutableReference::clone() const
 }
 
 RequestHandlerPtr
-IceInternal::RoutableReference::getRequestHandler(const Ice::ObjectPrx& proxy) const
+IceInternal::RoutableReference::getRequestHandler(const Ice::ObjectPrxPtr& proxy) const
 {
     return getInstance()->requestHandlerFactory()->getRequestHandler(const_cast<RoutableReference*>(this), proxy);
 }
@@ -1574,7 +1607,7 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
     {
     public:
 
-        class Callback2 : public Reference::GetConnectionCallback
+        class Callback2 ICE_FINAL : public Reference::GetConnectionCallback
         {
         public:
 
@@ -1604,10 +1637,10 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
                     {
                         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 one more time\n" << ex;
+                                << "removing endpoints from cache and trying again\n" << ex;
                         }
                         _reference->getConnectionNoRouterInfo(_callback); // Retry.
                         return;
@@ -1628,7 +1661,6 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
             const bool _cached;
         };
 
-
         virtual void
         setEndpoints(const vector<EndpointIPtr>& endpoints, bool cached)
         {
@@ -1640,7 +1672,7 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
 
             vector<EndpointIPtr> endpts = endpoints;
             _reference->applyOverrides(endpts);
-            _reference->createConnection(endpts, new Callback2(_reference, _callback, cached));
+            _reference->createConnection(endpts, ICE_MAKE_SHARED(Callback2, _reference, _callback, cached));
         }
 
         virtual void
@@ -1669,7 +1701,7 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
     if(_locatorInfo)
     {
         RoutableReference* self = const_cast<RoutableReference*>(this);
-        _locatorInfo->getEndpointsWithCallback(self, _locatorCacheTimeout, new Callback(self, callback));
+        _locatorInfo->getEndpoints(self, _locatorCacheTimeout, new Callback(self, callback));
     }
     else
     {
@@ -1761,14 +1793,14 @@ IceInternal::RoutableReference::createConnection(const vector& all
             virtual void
             setException(const Ice::LocalException& ex)
             {
-                if(!_exception.get())
+                if(!_exception)
                 {
-                    _exception.reset(ex.ice_clone());
+                    ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone());
                 }
 
                 if(++_i == _endpoints.size())
                 {
-                    _callback->setException(*_exception.get());
+                    _callback->setException(*_exception);
                     return;
                 }
 
@@ -1795,7 +1827,7 @@ IceInternal::RoutableReference::createConnection(const vector& all
             const vector<EndpointIPtr> _endpoints;
             const GetConnectionCallbackPtr _callback;
             size_t _i;
-            IceUtil::UniquePtr<Ice::LocalException> _exception;
+            IceInternal::UniquePtr<Ice::LocalException> _exception;
         };
 
         //
@@ -1851,6 +1883,7 @@ IceInternal::RoutableReference::RoutableReference(const RoutableReference& r) :
 namespace
 {
 
+#ifndef ICE_CPP11_COMPILER
 struct EndpointIsOpaque : public unary_function<EndpointIPtr, bool>
 {
 public:
@@ -1861,6 +1894,7 @@ public:
         return dynamic_cast<OpaqueEndpointI*>(p.get()) != 0;
     }
 };
+#endif
 
 }
 
@@ -1872,8 +1906,16 @@ IceInternal::RoutableReference::filterEndpoints(const vector& allE
     //
     // 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
     //
     // Filter out endpoints according to the mode of the reference.
     //
@@ -1886,8 +1928,17 @@ IceInternal::RoutableReference::filterEndpoints(const vector& allE
             //
             // 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
             break;
         }
 
@@ -1897,9 +1948,18 @@ IceInternal::RoutableReference::filterEndpoints(const vector& allE
             //
             // 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
             break;
         }
     }
@@ -1909,13 +1969,12 @@ IceInternal::RoutableReference::filterEndpoints(const vector& allE
     //
     switch(getEndpointSelection())
     {
-        case Random:
+        case ICE_ENUM(EndpointSelectionType, Random):
         {
-            RandomNumberGenerator rng;
-            random_shuffle(endpoints.begin(), endpoints.end(), rng);
+            IceUtilInternal::shuffle(endpoints.begin(), endpoints.end());
             break;
         }
-        case Ordered:
+        case ICE_ENUM(EndpointSelectionType, Ordered):
         {
             // Nothing to do.
             break;
@@ -1936,8 +1995,17 @@ IceInternal::RoutableReference::filterEndpoints(const vector& allE
     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())
     {
@@ -1946,7 +2014,15 @@ IceInternal::RoutableReference::filterEndpoints(const vector& allE
         // partition(), because otherwise some STL implementations
         // order our now randomized endpoints.
         //
-         stable_partition(endpoints.begin(), endpoints.end(), Ice::constMemFun(&EndpointI::secure));
+#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
     {
@@ -1955,7 +2031,15 @@ IceInternal::RoutableReference::filterEndpoints(const vector& allE
         // 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;