zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -18,7 +18,7 @@
 #include <Ice/ProxyFactory.h>
 #include <Ice/ThreadPool.h>
 #include <Ice/ConnectionFactory.h>
-#include <Ice/ObjectFactoryManager.h>
+#include <Ice/ValueFactoryManagerI.h>
 #include <Ice/LocalException.h>
 #include <Ice/ObjectAdapterFactory.h>
 #include <Ice/Exception.h>
@@ -42,9 +42,13 @@
 #include <Ice/LoggerAdminI.h>
 #include <Ice/RegisterPluginsInit.h>
 #include <Ice/ObserverHelper.h>
+#include <Ice/Functional.h>
+#include <Ice/ConsoleUtil.h>
 
+#include <IceUtil/DisableWarnings.h>
+#include <IceUtil/FileUtil.h>
 #include <IceUtil/StringUtil.h>
-#include <IceUtil/UUID.h>
+#include <Ice/UUID.h>
 #include <IceUtil/Mutex.h>
 #include <IceUtil/MutexPtrLock.h>
 #include <IceUtil/Atomic.h>
@@ -61,7 +65,7 @@
 #   include <sys/types.h>
 #endif
 
-#if defined(__linux__) || defined(__sun) || defined(_AIX) || defined(__GLIBC__)
+#if defined(__linux) || defined(__sun) || defined(_AIX) || defined(__GLIBC__)
 #   include <grp.h> // for initgroups
 #endif
 
@@ -72,8 +76,8 @@ using namespace IceInternal;
 namespace IceUtilInternal
 {
 
-extern bool ICE_UTIL_API nullHandleAbort;
-extern bool ICE_UTIL_API printStackTraces;
+extern bool nullHandleAbort;
+extern bool printStackTraces;
 
 };
 
@@ -138,16 +142,16 @@ public:
 
             if(notDestroyedCount > 0)
             {
-                cerr << "!! " << IceUtil::Time::now().toDateTime() << " error: ";
+                consoleErr << "!! " << IceUtil::Time::now().toDateTime() << " error: ";
                 if(notDestroyedCount == 1)
                 {
-                    cerr << "communicator ";
+                    consoleErr << "communicator ";
                 }
                 else
                 {
-                    cerr << notDestroyedCount << " communicators ";
+                    consoleErr << notDestroyedCount << " communicators ";
                 }
-                cerr << "not destroyed during global destruction.";
+                consoleErr << "not destroyed during global destruction.";
             }
 
             delete instanceList;
@@ -226,7 +230,7 @@ Timer::updateObserver(const Ice::Instrumentation::CommunicatorObserverPtr& obsv)
     assert(obsv);
     _observer.attach(obsv->getThreadObserver("Communicator",
                                             "Ice.Timer",
-                                            Ice::Instrumentation::ThreadStateIdle,
+                                            Instrumentation::ICE_ENUM(ThreadState, ThreadStateIdle),
                                             _observer.get()));
     _hasObserver.exchange(_observer.get() ? 1 : 0);
 }
@@ -243,8 +247,8 @@ Timer::runTimerTask(const IceUtil::TimerTaskPtr& task)
         }
         if(threadObserver)
         {
-            threadObserver->stateChanged(Ice::Instrumentation::ThreadStateIdle,
-                                         Ice::Instrumentation::ThreadStateInUseForOther);
+            threadObserver->stateChanged(Instrumentation::ICE_ENUM(ThreadState, ThreadStateIdle),
+                                         Instrumentation::ICE_ENUM(ThreadState, ThreadStateInUseForOther));
         }
         try
         {
@@ -254,14 +258,14 @@ Timer::runTimerTask(const IceUtil::TimerTaskPtr& task)
         {
             if(threadObserver)
             {
-                threadObserver->stateChanged(Ice::Instrumentation::ThreadStateInUseForOther,
-                                             Ice::Instrumentation::ThreadStateIdle);
+                threadObserver->stateChanged(Instrumentation::ICE_ENUM(ThreadState, ThreadStateInUseForOther),
+                                             Instrumentation::ICE_ENUM(ThreadState, ThreadStateIdle));
             }
         }
         if(threadObserver)
         {
-            threadObserver->stateChanged(Ice::Instrumentation::ThreadStateInUseForOther,
-                                         Ice::Instrumentation::ThreadStateIdle);
+            threadObserver->stateChanged(Instrumentation::ICE_ENUM(ThreadState, ThreadStateInUseForOther),
+                                         Instrumentation::ICE_ENUM(ThreadState, ThreadStateIdle));
         }
     }
     else
@@ -395,20 +399,6 @@ IceInternal::Instance::outgoingConnectionFactory() const
     return _outgoingConnectionFactory;
 }
 
-ObjectFactoryManagerPtr
-IceInternal::Instance::servantFactoryManager() const
-{
-    Lock sync(*this);
-
-    if(_state == StateDestroyed)
-    {
-        throw CommunicatorDestroyedException(__FILE__, __LINE__);
-    }
-
-    assert(_servantFactoryManager);
-    return _servantFactoryManager;
-}
-
 ObjectAdapterFactoryPtr
 IceInternal::Instance::objectAdapterFactory() const
 {
@@ -575,122 +565,7 @@ IceInternal::Instance::serverACM() const
     return _serverACM;
 }
 
-Identity
-IceInternal::Instance::stringToIdentity(const string& s) const
-{
-    //
-    // This method only accepts printable ascii. Since printable ascii is a subset
-    // of all narrow string encodings, it is not necessary to convert the string
-    // from the native string encoding. Any characters other than printable-ASCII
-    // will cause an IllegalArgumentException. Note that it can contain Unicode
-    // encoded in the escaped form which is the reason why we call fromUTF8 after
-    // unespcaping the printable ASCII string.
-    //
-
-    Identity ident;
-
-    //
-    // Find unescaped separator; note that the string may contain an escaped
-    // backslash before the separator.
-    //
-    string::size_type slash = string::npos, pos = 0;
-    while((pos = s.find('/', pos)) != string::npos)
-    {
-        int escapes = 0;
-        while(static_cast<int>(pos)- escapes > 0 && s[pos - escapes - 1] == '\\')
-        {
-            escapes++;
-        }
-
-        //
-        // We ignore escaped escapes
-        //
-        if(escapes % 2 == 0)
-        {
-            if(slash == string::npos)
-            {
-                slash = pos;
-            }
-            else
-            {
-                //
-                // Extra unescaped slash found.
-                //
-                IdentityParseException ex(__FILE__, __LINE__);
-                ex.str = "unescaped backslash in identity `" + s + "'";
-                throw ex;
-            }
-        }
-        pos++;
-    }
-
-    if(slash == string::npos)
-    {
-        try
-        {
-            ident.name = IceUtilInternal::unescapeString(s, 0, s.size());
-        }
-        catch(const IceUtil::IllegalArgumentException& e)
-        {
-            IdentityParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid identity name `" + s + "': " + e.reason();
-            throw ex;
-        }
-    }
-    else
-    {
-        try
-        {
-            ident.category = IceUtilInternal::unescapeString(s, 0, slash);
-        }
-        catch(const IceUtil::IllegalArgumentException& e)
-        {
-            IdentityParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid category in identity `" + s + "': " + e.reason();
-            throw ex;
-        }
-        if(slash + 1 < s.size())
-        {
-            try
-            {
-                ident.name = IceUtilInternal::unescapeString(s, slash + 1, s.size());
-            }
-            catch(const IceUtil::IllegalArgumentException& e)
-            {
-                IdentityParseException ex(__FILE__, __LINE__);
-                ex.str = "invalid name in identity `" + s + "': " + e.reason();
-                throw ex;
-            }
-        }
-    }
-
-    ident.name = UTF8ToNative(ident.name, _stringConverter);
-    ident.category = UTF8ToNative(ident.category, _stringConverter);
-
-    return ident;
-}
-
-string
-IceInternal::Instance::identityToString(const Identity& ident) const
-{
-    //
-    // This method returns the stringified identity. The returned string only
-    // contains printable ascii. It can contain UTF8 in the escaped form.
-    //
-    string name = nativeToUTF8(ident.name, _stringConverter);
-    string category = nativeToUTF8(ident.category, _stringConverter);
-
-    if(category.empty())
-    {
-        return IceUtilInternal::escapeString(name, "/");
-    }
-    else
-    {
-        return IceUtilInternal::escapeString(category, "/") + '/' + IceUtilInternal::escapeString(name, "/");
-    }
-}
-
-Ice::ObjectPrx
+Ice::ObjectPrxPtr
 IceInternal::Instance::createAdmin(const ObjectAdapterPtr& adminAdapter, const Identity& adminIdentity)
 {
     ObjectAdapterPtr adapter = adminAdapter;
@@ -758,7 +633,7 @@ IceInternal::Instance::createAdmin(const ObjectAdapterPtr& adminAdapter, const I
     return adapter->createProxy(adminIdentity);
 }
 
-Ice::ObjectPrx
+Ice::ObjectPrxPtr
 IceInternal::Instance::getAdmin()
 {
     Lock sync(*this);
@@ -789,7 +664,7 @@ IceInternal::Instance::getAdmin()
         adminIdentity.category = _initData.properties->getProperty("Ice.Admin.InstanceName");
         if(adminIdentity.category.empty())
         {
-            adminIdentity.category = IceUtil::generateUUID();
+            adminIdentity.category = Ice::generateUUID();
         }
 
         _adminIdentity = adminIdentity;
@@ -849,12 +724,12 @@ IceInternal::Instance::addAllAdminFacets()
 void
 IceInternal::Instance::setServerProcessProxy(const ObjectAdapterPtr& adminAdapter, const Identity& adminIdentity)
 {
-    ObjectPrx admin = adminAdapter->createProxy(adminIdentity);
-    LocatorPrx locator = adminAdapter->getLocator();
+    ObjectPrxPtr admin = adminAdapter->createProxy(adminIdentity);
+    LocatorPrxPtr locator = adminAdapter->getLocator();
     const string serverId = _initData.properties->getProperty("Ice.Admin.ServerId");
     if(locator && serverId != "")
     {
-        ProcessPrx process = ProcessPrx::uncheckedCast(admin->ice_facet("Process"));
+        ProcessPrxPtr process = ICE_UNCHECKED_CAST(ProcessPrx, admin->ice_facet("Process"));
         try
         {
             //
@@ -1008,7 +883,7 @@ IceInternal::Instance::findAllAdminFacets()
 }
 
 void
-IceInternal::Instance::setDefaultLocator(const Ice::LocatorPrx& defaultLocator)
+IceInternal::Instance::setDefaultLocator(const Ice::LocatorPrxPtr& defaultLocator)
 {
     Lock sync(*this);
 
@@ -1021,7 +896,7 @@ IceInternal::Instance::setDefaultLocator(const Ice::LocatorPrx& defaultLocator)
 }
 
 void
-IceInternal::Instance::setDefaultRouter(const Ice::RouterPrx& defaultRouter)
+IceInternal::Instance::setDefaultRouter(const Ice::RouterPrxPtr& defaultRouter)
 {
     Lock sync(*this);
 
@@ -1042,6 +917,14 @@ IceInternal::Instance::setLogger(const Ice::LoggerPtr& logger)
     _initData.logger = logger;
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+IceInternal::Instance::setThreadHook(function<void()> threadStart, function<void()> threadStop)
+{
+    _initData.threadStart = move(threadStart);
+    _initData.threadStop = move(threadStop);
+}
+#else
 void
 IceInternal::Instance::setThreadHook(const Ice::ThreadNotificationPtr& threadHook)
 {
@@ -1050,6 +933,7 @@ IceInternal::Instance::setThreadHook(const Ice::ThreadNotificationPtr& threadHoo
     //
     _initData.threadHook = threadHook;
 }
+#endif
 
 namespace
 {
@@ -1065,9 +949,10 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
     _batchAutoFlushSize(0),
     _classGraphDepthMax(0),
     _collectObjects(false),
+    _toStringMode(ICE_ENUM(ToStringMode, Unicode)),
     _implicitContext(0),
-    _stringConverter(IceUtil::getProcessStringConverter()),
-    _wstringConverter(IceUtil::getProcessWstringConverter()),
+    _stringConverter(Ice::getProcessStringConverter()),
+    _wstringConverter(Ice::getProcessWstringConverter()),
     _adminEnabled(false)
 {
     try
@@ -1121,12 +1006,15 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
 
 #ifdef NDEBUG
                 if(_initData.properties->getPropertyAsIntWithDefault("Ice.PrintStackTraces", 0) > 0)
-#else
-                if(_initData.properties->getPropertyAsIntWithDefault("Ice.PrintStackTraces", 1) > 0)
-#endif
                 {
                     IceUtilInternal::printStackTraces = true;
                 }
+#else
+                if(_initData.properties->getPropertyAsIntWithDefault("Ice.PrintStackTraces", 1) == 0)
+                {
+                    IceUtilInternal::printStackTraces = false;
+                }
+#endif
 
 #ifndef _WIN32
                 string newUser = _initData.properties->getProperty("Ice.ChangeUser");
@@ -1135,9 +1023,8 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
                     struct passwd pwbuf;
                     vector<char> buffer(4096); // 4KB initial buffer
                     struct passwd *pw;
-                    int err;
-                    while((err =  getpwnam_r(newUser.c_str(), &pwbuf, &buffer[0], buffer.size(), &pw)) == ERANGE &&
-                          buffer.size() < 1024 * 1024) // Limit buffer to 1M
+                    int err = getpwnam_r(newUser.c_str(), &pwbuf, &buffer[0], buffer.size(), &pw);
+                    while(err == ERANGE && buffer.size() < 1024 * 1024) // Limit buffer to 1MB
                     {
                         buffer.resize(buffer.size() * 2);
                     }
@@ -1181,7 +1068,7 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
 
             if(instanceCount() == 1)
             {
-#if defined(_WIN32) && !defined(ICE_OS_WINRT)
+#if defined(_WIN32) && !defined(ICE_OS_UWP)
                 WORD version = MAKEWORD(1, 1);
                 WSADATA data;
                 if(WSAStartup(version, &data) != 0)
@@ -1226,25 +1113,23 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
                     throw InitializationException(__FILE__, __LINE__, "Both syslog and file logger cannot be enabled.");
                 }
 
-                _initData.logger =
-                    new SysLoggerI(_initData.properties->getProperty("Ice.ProgramName"),
-                                   _initData.properties->getPropertyWithDefault("Ice.SyslogFacility", "LOG_USER"));
+                _initData.logger = ICE_MAKE_SHARED(SysLoggerI,
+                                                   _initData.properties->getProperty("Ice.ProgramName"),
+                                                   _initData.properties->getPropertyWithDefault("Ice.SyslogFacility", "LOG_USER"));
             }
             else
 #endif
             if(!logfile.empty())
             {
-                _initData.logger =
-                        new LoggerI(_initData.properties->getProperty("Ice.ProgramName"), logfile, true, 0,
-                                    _initData.properties->getPropertyAsIntWithDefault("Ice.LogFile.SizeMax", 0));
+                _initData.logger = ICE_MAKE_SHARED(LoggerI, _initData.properties->getProperty("Ice.ProgramName"), logfile, true,
+                                                            _initData.properties->getPropertyAsIntWithDefault("Ice.LogFile.SizeMax", 0));
             }
             else
             {
                 _initData.logger = getProcessLogger();
-                if(LoggerIPtr::dynamicCast(_initData.logger))
+                if(ICE_DYNAMIC_CAST(LoggerI, _initData.logger))
                 {
-                    _initData.logger = new LoggerI(_initData.properties->getProperty("Ice.ProgramName"), "",
-                                                   logStdErrConvert, _stringConverter);
+                    _initData.logger = ICE_MAKE_SHARED(LoggerI, _initData.properties->getProperty("Ice.ProgramName"), "", logStdErrConvert);
                 }
             }
         }
@@ -1308,7 +1193,7 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
         }
 
         {
-            static const int defaultValue = 0; // Disabled by default
+            static const int defaultValue = 100;
             Int num = _initData.properties->getPropertyAsIntWithDefault("Ice.ClassGraphDepthMax", defaultValue);
             if(num < 1 || static_cast<size_t>(num) > static_cast<size_t>(0x7fffffff))
             {
@@ -1322,10 +1207,24 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
 
         const_cast<bool&>(_collectObjects) = _initData.properties->getPropertyAsInt("Ice.CollectObjects") > 0;
 
+        string toStringModeStr = _initData.properties->getPropertyWithDefault("Ice.ToStringMode", "Unicode");
+        if(toStringModeStr == "ASCII")
+        {
+            const_cast<ToStringMode&>(_toStringMode) = ICE_ENUM(ToStringMode, ASCII);
+        }
+        else if(toStringModeStr == "Compat")
+        {
+            const_cast<ToStringMode&>(_toStringMode) = ICE_ENUM(ToStringMode, Compat);
+        }
+        else if(toStringModeStr != "Unicode")
+        {
+            throw InitializationException(__FILE__, __LINE__, "The value for Ice.ToStringMode must be Unicode, ASCII or Compat");
+        }
+
         //
         // Client ACM enabled by default. Server ACM disabled by default.
         //
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
         const_cast<ImplicitContextIPtr&>(_implicitContext) =
             ImplicitContextI::create(_initData.properties->getProperty("Ice.ImplicitContext"));
 #endif
@@ -1366,23 +1265,20 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
 
         _dynamicLibraryList = new DynamicLibraryList;
 
-        _pluginManager = new PluginManagerI(communicator, _dynamicLibraryList);
+        _pluginManager = ICE_MAKE_SHARED(PluginManagerI, communicator, _dynamicLibraryList);
 
-        _outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this);
+        if(!_initData.valueFactoryManager)
+        {
+            _initData.valueFactoryManager = ICE_MAKE_SHARED(ValueFactoryManagerI);
+        }
 
-        _servantFactoryManager = new ObjectFactoryManager();
+        _objectFactoryMapHint = _objectFactoryMap.end();
 
-        _objectAdapterFactory = new ObjectAdapterFactory(this, communicator);
+        _outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this);
 
-        _retryQueue = new RetryQueue(this);
+        _objectAdapterFactory = ICE_MAKE_SHARED(ObjectAdapterFactory, this, communicator);
 
-        //
-        // When _wstringConverter isn't set, use the default Unicode wstring converter
-        //
-        if(!_wstringConverter)
-        {
-            _wstringConverter = new IceUtil::UnicodeWstringConverter;
-        }
+        _retryQueue = new RetryQueue(this);
 
         __setNoDelete(false);
     }
@@ -1405,7 +1301,6 @@ IceInternal::Instance::~Instance()
     assert(!_proxyFactory);
     assert(!_outgoingConnectionFactory);
 
-    assert(!_servantFactoryManager);
     assert(!_objectAdapterFactory);
     assert(!_clientThreadPool);
     assert(!_serverThreadPool);
@@ -1425,7 +1320,7 @@ IceInternal::Instance::~Instance()
     }
     if(instanceCount() == 0)
     {
-#if defined(_WIN32) && !defined(ICE_OS_WINRT)
+#if defined(_WIN32) && !defined(ICE_OS_UWP)
         WSACleanup();
 #endif
 
@@ -1442,7 +1337,7 @@ IceInternal::Instance::~Instance()
 }
 
 void
-IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::CommunicatorPtr& communicator)
+IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::CommunicatorPtr& communicator)
 {
     //
     // Load plug-ins.
@@ -1453,35 +1348,16 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
     pluginManagerImpl->loadPlugins(argc, argv);
 
     //
-    // Add WS and WSS endpoint factories if TCP/SSL factories are installed.
+    // Initialize the endpoint factories once all the plugins are loaded. This gives
+    // the opportunity for the endpoint factories to find underyling factories.
     //
-    EndpointFactoryPtr tcpFactory = _endpointFactoryManager->get(TCPEndpointType);
-    if(tcpFactory)
-    {
-        ProtocolInstancePtr instance = new ProtocolInstance(communicator, WSEndpointType, "ws", false);
-        _endpointFactoryManager->add(new WSEndpointFactory(instance, tcpFactory->clone(instance)));
-    }
-    EndpointFactoryPtr sslFactory = _endpointFactoryManager->get(SSLEndpointType);
-    if(sslFactory)
-    {
-        ProtocolInstancePtr instance = new ProtocolInstance(communicator, WSSEndpointType, "wss", true);
-        _endpointFactoryManager->add(new WSEndpointFactory(instance, sslFactory->clone(instance)));
-    }
+    _endpointFactoryManager->initialize();
 
     //
     // Reset _stringConverter and _wstringConverter, in case a plugin changed them
     //
-    _stringConverter = IceUtil::getProcessStringConverter();
-
-    IceUtil::WstringConverterPtr newWstringConverter = IceUtil::getProcessWstringConverter();
-    if(newWstringConverter)
-    {
-        _wstringConverter = newWstringConverter;
-    }
-    else
-    {
-        _wstringConverter = new IceUtil::UnicodeWstringConverter;
-    }
+    _stringConverter = Ice::getProcessStringConverter();
+    _wstringConverter = Ice::getProcessWstringConverter();
 
     //
     // Create Admin facets, if enabled.
@@ -1513,7 +1389,7 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
         const string processFacetName = "Process";
         if(_adminFacetFilter.empty() || _adminFacetFilter.find(processFacetName) != _adminFacetFilter.end())
         {
-            _adminFacets.insert(make_pair(processFacetName, new ProcessI(communicator)));
+            _adminFacets.insert(make_pair(processFacetName, ICE_MAKE_SHARED(ProcessI, communicator)));
         }
 
         //
@@ -1534,7 +1410,7 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
         PropertiesAdminIPtr propsAdmin;
         if(_adminFacetFilter.empty() || _adminFacetFilter.find(propertiesFacetName) != _adminFacetFilter.end())
         {
-            propsAdmin = new PropertiesAdminI(_initData.properties, _initData.logger);
+            propsAdmin = ICE_MAKE_SHARED(PropertiesAdminI, this);
             _adminFacets.insert(make_pair(propertiesFacetName, propsAdmin));
         }
 
@@ -1544,7 +1420,7 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
         const string metricsFacetName = "Metrics";
         if(_adminFacetFilter.empty() || _adminFacetFilter.find(metricsFacetName) != _adminFacetFilter.end())
         {
-            CommunicatorObserverIPtr observer = new CommunicatorObserverI(_initData);
+            CommunicatorObserverIPtr observer = ICE_MAKE_SHARED(CommunicatorObserverI, _initData);
             _initData.observer = observer;
             _adminFacets.insert(make_pair(metricsFacetName, observer->getFacet()));
 
@@ -1553,7 +1429,13 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
             //
             if(propsAdmin)
             {
+#ifdef ICE_CPP11_MAPPING
+                auto metricsAdmin = observer->getFacet();
+                propsAdmin->addUpdateCallback(
+                    [metricsAdmin](const PropertyDict& changes) { metricsAdmin->updated(changes); });
+#else
                 propsAdmin->addUpdateCallback(observer->getFacet());
+#endif
             }
         }
     }
@@ -1563,7 +1445,7 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
     //
     if(_initData.observer)
     {
-        _initData.observer->setObserverUpdater(new ObserverUpdaterI(this));
+        _initData.observer->setObserverUpdater(ICE_MAKE_SHARED(ObserverUpdaterI, this));
     }
 
     //
@@ -1608,7 +1490,7 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
     //
     if(!_referenceFactory->getDefaultRouter())
     {
-        RouterPrx router = RouterPrx::uncheckedCast(_proxyFactory->propertyToProxy("Ice.Default.Router"));
+        RouterPrxPtr router = ICE_UNCHECKED_CAST(RouterPrx, _proxyFactory->propertyToProxy("Ice.Default.Router"));
         if(router)
         {
             _referenceFactory = _referenceFactory->setDefaultRouter(router);
@@ -1617,7 +1499,7 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
 
     if(!_referenceFactory->getDefaultLocator())
     {
-        LocatorPrx locator = LocatorPrx::uncheckedCast(_proxyFactory->propertyToProxy("Ice.Default.Locator"));
+        LocatorPrxPtr locator = ICE_UNCHECKED_CAST(LocatorPrx, _proxyFactory->propertyToProxy("Ice.Default.Locator"));
         if(locator)
         {
             _referenceFactory = _referenceFactory->setDefaultLocator(locator);
@@ -1645,9 +1527,9 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
     if(printProcessId)
     {
 #ifdef _MSC_VER
-        cout << GetCurrentProcessId() << endl;
+        consoleOut << GetCurrentProcessId() << endl;
 #else
-        cout << getpid() << endl;
+        consoleOut << getpid() << endl;
 #endif
     }
 
@@ -1734,7 +1616,7 @@ IceInternal::Instance::destroy()
 
     if(_initData.observer)
     {
-        CommunicatorObserverIPtr observer = CommunicatorObserverIPtr::dynamicCast(_initData.observer);
+        CommunicatorObserverIPtr observer = ICE_DYNAMIC_CAST(CommunicatorObserverI, _initData.observer);
         if(observer)
         {
             observer->destroy(); // Break cyclic reference counts. Don't clear _observer, it's immutable.
@@ -1742,7 +1624,7 @@ IceInternal::Instance::destroy()
         _initData.observer->setObserverUpdater(0); // Break cyclic reference count.
     }
 
-    LoggerAdminLoggerPtr logger = LoggerAdminLoggerPtr::dynamicCast(_initData.logger);
+    LoggerAdminLoggerPtr logger = ICE_DYNAMIC_CAST(LoggerAdminLogger, _initData.logger);
     if(logger)
     {
         //
@@ -1784,17 +1666,16 @@ IceInternal::Instance::destroy()
     {
         _serverThreadPool->joinWithAllThreads();
     }
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     if(_endpointHostResolver)
     {
         _endpointHostResolver->getThreadControl().join();
     }
 #endif
 
-    if(_servantFactoryManager)
-    {
-        _servantFactoryManager->destroy();
-    }
+    for_each(_objectFactoryMap.begin(), _objectFactoryMap.end(),
+        Ice::secondVoidMemFun<const string, ObjectFactory>(&ObjectFactory::destroy));
+    _objectFactoryMap.clear();
 
     if(_routerManager)
     {
@@ -1845,7 +1726,6 @@ IceInternal::Instance::destroy()
         _endpointHostResolver = 0;
         _timer = 0;
 
-        _servantFactoryManager = 0;
         _referenceFactory = 0;
         _requestHandlerFactory = 0;
         _proxyFactory = 0;
@@ -1957,6 +1837,82 @@ IceInternal::Instance::setRcvBufSizeWarn(Short type, int size)
     _setBufSizeWarn[type] =  info;
 }
 
+void
+IceInternal::Instance::addObjectFactory(const Ice::ObjectFactoryPtr& factory, const string& id)
+{
+    Lock sync(*this);
+
+    //
+    // Create a ValueFactory wrapper around the given ObjectFactory and register the wrapper
+    // with the value factory manager. This may raise AlreadyRegisteredException.
+    //
+#ifdef ICE_CPP11_MAPPING
+    _initData.valueFactoryManager->add([factory](const string& id)
+                                       {
+                                           return factory->create(id);
+                                       },
+                                       id);
+#else
+    class ValueFactoryWrapper: public Ice::ValueFactory
+    {
+    public:
+
+        ValueFactoryWrapper(const Ice::ObjectFactoryPtr& factory) :  _objectFactory(factory)
+        {
+        }
+
+        Ice::ValuePtr create(const std::string& id)
+        {
+            return _objectFactory->create(id);
+        }
+
+    private:
+
+        Ice::ObjectFactoryPtr _objectFactory;
+    };
+
+    _initData.valueFactoryManager->add(new ValueFactoryWrapper(factory), id);
+#endif
+
+    //
+    // Also record the object factory in our own map.
+    //
+    _objectFactoryMapHint = _objectFactoryMap.insert(_objectFactoryMapHint,
+                                                     pair<const string, Ice::ObjectFactoryPtr>(id, factory));
+}
+
+Ice::ObjectFactoryPtr
+IceInternal::Instance::findObjectFactory(const string& id) const
+{
+    Lock sync(*this);
+
+    ObjectFactoryMap& objectfactoryMap = const_cast<ObjectFactoryMap&>(_objectFactoryMap);
+
+    ObjectFactoryMap::iterator p = objectfactoryMap.end();
+    if(_objectFactoryMapHint != objectfactoryMap.end())
+    {
+        if(_objectFactoryMapHint->first == id)
+        {
+            p = _objectFactoryMapHint;
+        }
+    }
+
+    if(p == objectfactoryMap.end())
+    {
+        p = objectfactoryMap.find(id);
+    }
+
+    if(p != objectfactoryMap.end())
+    {
+        _objectFactoryMapHint = p;
+        return p->second;
+    }
+    else
+    {
+        return ICE_NULLPTR;
+    }
+}
+
 IceInternal::ProcessI::ProcessI(const CommunicatorPtr& communicator) :
     _communicator(communicator)
 {
@@ -1969,18 +1925,22 @@ IceInternal::ProcessI::shutdown(const Current&)
 }
 
 void
+#ifdef ICE_CPP11_MAPPING
+IceInternal::ProcessI::writeMessage(string message, Int fd, const Current&)
+#else
 IceInternal::ProcessI::writeMessage(const string& message, Int fd, const Current&)
+#endif
 {
     switch(fd)
     {
         case 1:
         {
-            cout << message << endl;
+            consoleOut << message << endl;
             break;
         }
         case 2:
         {
-            cerr << message << endl;
+            consoleErr << message << endl;
             break;
         }
     }