zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/IncomingAsync.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/IncomingAsync.h>
 #include <Ice/ServantLocator.h>
@@ -23,9 +18,21 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(IncomingAsync* p) { return p; }
 IceUtil::Shared* Ice::upCast(AMD_Object_ice_invoke* p) { return p; }
 
+Ice::AMDCallback::~AMDCallback()
+{
+    // Out of line to avoid weak vtable
+}
+
+Ice::AMD_Object_ice_invoke::~AMD_Object_ice_invoke()
+{
+    // Out of line to avoid weak vtable
+}
+#endif
+
 namespace
 {
 
@@ -53,288 +60,171 @@ Init init;
 
 IceInternal::IncomingAsync::IncomingAsync(Incoming& in) :
     IncomingBase(in),
-    _instanceCopy(_os.instance()),
-    _responseHandlerCopy(_responseHandler),
-    _retriable(in.isRetriable()),
-    _active(true)
+    _responseSent(false),
+    _responseHandlerCopy(ICE_GET_SHARED_FROM_THIS(_responseHandler))
 {
-    if(_retriable)
-    {
-        in.setActive(*this);
-    }
+#ifndef ICE_CPP11_MAPPING
+    in.setAsync(this);
+#endif
 }
 
+#ifdef ICE_CPP11_MAPPING
+shared_ptr<IncomingAsync>
+IceInternal::IncomingAsync::create(Incoming& in)
+{
+    auto async = make_shared<IncomingAsync>(in);
+    in.setAsync(async);
+    return async;
+}
+#endif
+
+#ifndef ICE_CPP11_MAPPING
 void
-IceInternal::IncomingAsync::__deactivate(Incoming& in)
+IceInternal::IncomingAsync::ice_exception(const ::std::exception& exc)
 {
-    assert(_retriable);
+    try
     {
-        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
-        if(!_active)
+        for(DispatchInterceptorCallbacks::iterator p = _interceptorCBs.begin(); p != _interceptorCBs.end(); ++p)
         {
-            //
-            // Since _deactivate can only be called on an active object,
-            // this means the response has already been sent (see __validateXXX below)
-            //
-            throw ResponseSentException(__FILE__, __LINE__);
+            if(!(*p)->exception(exc))
+            {
+                return;
+            }
         }
-        _active = false;
+    }
+    catch(...)
+    {
+        return;
     }
 
-    in.__adopt(*this);
+    checkResponseSent();
+    IncomingBase::exception(exc, true); // User thread
 }
 
 void
-IceInternal::IncomingAsync::ice_exception(const ::std::exception& ex)
+IceInternal::IncomingAsync::ice_exception()
 {
-    //
-    // Only call __exception if this incoming is not retriable or if
-    // all the interceptors return true and no response has been sent
-    // yet.
-    //
-
-    if(_retriable)
+    try
     {
-        try
+        for(DispatchInterceptorCallbacks::iterator p = _interceptorCBs.begin(); p != _interceptorCBs.end(); ++p)
         {
-            for(deque<Ice::DispatchInterceptorAsyncCallbackPtr>::iterator p = _interceptorAsyncCallbackQueue.begin();
-                p != _interceptorAsyncCallbackQueue.end(); ++p)
+            if(!(*p)->exception())
             {
-                if((*p)->exception(ex) == false)
-                {
-                    return;
-                }
+                return;
             }
         }
-        catch(...)
-        {
-            return;
-        }
-    
-        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
-        if(!_active)
-        {
-            return;
-        }
-        _active = false;
     }
-
-    if(_responseHandler)
+    catch(...)
     {
-        __exception(ex);
-    }
-    else
-    {
-        //
-        // Response has already been sent.
-        //
-        if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0)
-        {
-            __warning(ex.what());
-        }
+        return;
     }
+
+    checkResponseSent();
+    IncomingBase::exception("unknown c++ exception", true); // User thread
 }
 
+#endif
+
 void
-IceInternal::IncomingAsync::ice_exception()
+IceInternal::IncomingAsync::kill(Incoming& in)
 {
-    //
-    // Only call __exception if this incoming is not retriable or if
-    // all the interceptors return true and no response has been sent
-    // yet.
-    //
+    checkResponseSent();
+    in._observer.adopt(_observer); // Give back the observer to incoming.
+}
 
-    if(_retriable)
+void
+IceInternal::IncomingAsync::completed()
+{
+    for(DispatchInterceptorCallbacks::iterator p = _interceptorCBs.begin(); p != _interceptorCBs.end(); ++p)
     {
         try
         {
-            for(deque<Ice::DispatchInterceptorAsyncCallbackPtr>::iterator p = _interceptorAsyncCallbackQueue.begin();
-                p != _interceptorAsyncCallbackQueue.end(); ++p)
+#ifdef ICE_CPP11_MAPPING
+            if(p->first && !p->first())
+#else
+            if(!(*p)->response())
+#endif
             {
-                if((*p)->exception() == false)
-                {
-                    return;
-                }
+                return;
             }
         }
         catch(...)
         {
-            return;
-        }
-    
-        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
-        if(!_active)
-        {
-            return;
         }
-        _active = false;
     }
 
-    if(_responseHandler)
-    {
-        __exception();
-    }
-    else
-    {
-        //
-        // Response has already been sent.
-        //
-        if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0)
-        {
-            __warning("unknown exception");
-        }
-    }
+    checkResponseSent();
+    IncomingBase::response(true); // User thread
 }
 
+#ifdef ICE_CPP11_MAPPING
 void
-IceInternal::IncomingAsync::__response()
+IceInternal::IncomingAsync::completed(exception_ptr ex)
 {
-    try
+    for(DispatchInterceptorCallbacks::iterator p = _interceptorCBs.begin(); p != _interceptorCBs.end(); ++p)
     {
-        if(_locator && !__servantLocatorFinished(true))
-        {
-            return;
-        }
-
-        assert(_responseHandler);
-
-        if(_response)
+        try
         {
-            _observer.reply(static_cast<Int>(_os.b.size() - headerSize - 4));
-            _responseHandler->sendResponse(_current.requestId, &_os, _compress, true);
+            if(p->second && !p->second(ex))
+            {
+                return;
+            }
         }
-        else
+        catch(...)
         {
-            _responseHandler->sendNoResponse();
         }
-
-        _observer.detach();
-        _responseHandler = 0;
     }
-    catch(const LocalException& ex)
-    {
-        _responseHandler->invokeException(_current.requestId, ex, 1, true); // Fatal invocation exception
-    }
-}
 
-void
-IceInternal::IncomingAsync::__exception(const std::exception& exc)
-{
+    checkResponseSent();
     try
     {
-        if(_locator && !__servantLocatorFinished(true))
-        {
-            return;
-        }
-
-        __handleException(exc, true);
+        rethrow_exception(ex);
     }
-    catch(const LocalException& ex)
+    catch(const std::exception& exc)
     {
-        _responseHandler->invokeException(_current.requestId, ex, 1, true);  // Fatal invocation exception
+        IncomingBase::exception(exc, true); // User thread
     }
-}
-
-void
-IceInternal::IncomingAsync::__exception()
-{
-    try
+    catch(...)
     {
-        if(_locator && !__servantLocatorFinished(true))
-        {
-            return;
-        }
-
-        __handleException(true);
-    }
-    catch(const LocalException& ex)
-    {
-        _responseHandler->invokeException(_current.requestId, ex, 1, true);  // Fatal invocation exception
+        IncomingBase::exception("unknown c++ exception", true); // User thread
     }
 }
+#endif
 
-bool
-IceInternal::IncomingAsync::__validateResponse(bool ok)
+void
+IceInternal::IncomingAsync::checkResponseSent()
 {
-    //
-    // Only returns true if this incoming is not retriable or if all
-    // the interceptors return true and no response has been sent
-    // yet. Upon getting a true return value, the caller should send
-    // the response.
-    //
-
-    if(_retriable)
+    IceUtil::Mutex::Lock sync(*globalMutex);
+    if(_responseSent)
     {
-        try
-        {
-            for(deque<DispatchInterceptorAsyncCallbackPtr>::iterator p = _interceptorAsyncCallbackQueue.begin();
-                p != _interceptorAsyncCallbackQueue.end(); ++p)
-            {
-                if((*p)->response(ok) == false)
-                {
-                    return false;
-                }
-            }
-        }
-        catch(...)
-        {
-            return false;
-        }
-        
-        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
-        if(!_active)
-        {
-            return false;
-        }
-        _active = false;
+        throw ResponseSentException(__FILE__, __LINE__);
     }
-    return true;
+    _responseSent = true;
 }
 
-IceAsync::Ice::AMD_Object_ice_invoke::AMD_Object_ice_invoke(Incoming& in) :
-    IncomingAsync(in)
+#ifndef ICE_CPP11_MAPPING
+IceAsync::Ice::AMD_Object_ice_invoke::AMD_Object_ice_invoke(Incoming& in) : IncomingAsync(in)
 {
 }
 
 void
 IceAsync::Ice::AMD_Object_ice_invoke::ice_response(bool ok, const vector<Byte>& outEncaps)
 {
-    if(__validateResponse(ok))
+    if(outEncaps.empty())
     {
-        try
-        {
-            if(outEncaps.empty())
-            {
-                __writeParamEncaps(0, 0, ok);
-            }
-            else
-            {
-                __writeParamEncaps(&outEncaps[0], static_cast< ::Ice::Int>(outEncaps.size()), ok);
-            }
-        }
-        catch(const LocalException& ex)
-        {
-            __exception(ex);
-            return;
-        }
-        __response();
+        writeParamEncaps(0, 0, ok);
     }
+    else
+    {
+        writeParamEncaps(&outEncaps[0], static_cast<Int>(outEncaps.size()), ok);
+    }
+    completed();
 }
 
 void
 IceAsync::Ice::AMD_Object_ice_invoke::ice_response(bool ok, const pair<const Byte*, const Byte*>& outEncaps)
 {
-    if(__validateResponse(ok))
-    {
-        try
-        {
-            __writeParamEncaps(outEncaps.first, static_cast<Int>(outEncaps.second - outEncaps.first), ok);
-        }
-        catch(const LocalException& ex)
-        {
-            __exception(ex);
-            return;
-        }
-        __response();
-    }
+    writeParamEncaps(outEncaps.first, static_cast<Int>(outEncaps.second - outEncaps.first), ok);
+    completed();
 }
+#endif

data/ext/ice/cpp/src/Ice/IncomingRequest.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_INCOMING_REQUEST_H
 #define ICE_INCOMING_REQUEST_H
@@ -23,15 +18,16 @@ namespace IceInternal
 class ICE_API IncomingRequest : public Ice::Request
 {
 public:
-    IncomingRequest(Incoming& in) :
-        _in(in)
+
+    IncomingRequest(Incoming& in) : _in(in)
     {
     }
 
     virtual const Ice::Current& getCurrent();
-    
+
     Incoming& _in;
 };
+
 }
 
 #endif

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

@@ -1,25 +1,19 @@
-// **********************************************************************
 //
-// 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/ArgVector.h>
+#include <Ice/ArgVector.h>
 #include <Ice/CommunicatorI.h>
 #include <Ice/PropertiesI.h>
 #include <Ice/Initialize.h>
 #include <Ice/LocalException.h>
-#include <Ice/StreamI.h>
 #include <Ice/LoggerI.h>
 #include <Ice/Instance.h>
 #include <Ice/PluginManagerI.h>
-#include <IceUtil/StringUtil.h>
+#include <Ice/StringUtil.h>
 #include <IceUtil/Mutex.h>
 #include <IceUtil/MutexPtrLock.h>
-#include <IceUtil/StringConverter.h>
+#include <Ice/StringConverter.h>
 
 using namespace std;
 using namespace Ice;
@@ -28,19 +22,6 @@ using namespace IceInternal;
 namespace
 {
 
-pair<const Byte*, const Byte*>
-makePair(const vector<Byte>& v)
-{
-    if(v.empty())
-    {
-        return pair<const Byte*, const Byte*>(static_cast<Byte*>(0), static_cast<Byte*>(0));
-    }
-    else
-    {
-        return pair<const Byte*, const Byte*>(&v[0], &v[0] + v.size());
-    }
-}
-
 IceUtil::Mutex* globalMutex = 0;
 Ice::LoggerPtr processLogger;
 
@@ -65,7 +46,7 @@ Init init;
 }
 
 StringSeq
-Ice::argsToStringSeq(int argc, char* argv[])
+Ice::argsToStringSeq(int argc, const char* const argv[])
 {
     StringSeq result;
     for(int i = 0; i < argc; i++)
@@ -78,17 +59,17 @@ Ice::argsToStringSeq(int argc, char* argv[])
 #ifdef _WIN32
 
 StringSeq
-Ice::argsToStringSeq(int /*argc*/, wchar_t* argv[])
+Ice::argsToStringSeq(int /*argc*/, const wchar_t* const argv[])
 {
     //
     // Don't need to use a wide string converter argv is expected to
     // come from Windows API.
     //
-    const IceUtil::StringConverterPtr converter = IceUtil::getProcessStringConverter();
+    const StringConverterPtr converter = getProcessStringConverter();
     StringSeq args;
-    for(int i=0; argv[i] != 0; i++)
+    for(int i = 0; argv[i] != 0; i++)
     {
-        args.push_back(IceUtil::wstringToString(argv[i], converter));
+        args.push_back(wstringToString(argv[i], converter));
     }
     return args;
 }
@@ -96,7 +77,7 @@ Ice::argsToStringSeq(int /*argc*/, wchar_t* argv[])
 #endif
 
 void
-Ice::stringSeqToArgs(const StringSeq& args, int& argc, char* argv[])
+Ice::stringSeqToArgs(const StringSeq& args, int& argc, const char* argv[])
 {
     //
     // Shift all elements in argv which are present in args to the
@@ -132,20 +113,65 @@ Ice::stringSeqToArgs(const StringSeq& args, int& argc, char* argv[])
     }
 }
 
+#ifdef _WIN32
+void
+Ice::stringSeqToArgs(const StringSeq& args, int& argc, const wchar_t* argv[])
+{
+    //
+    // Don't need to use a wide string converter argv is expected to
+    // come from Windows API.
+    //
+    const StringConverterPtr converter = getProcessStringConverter();
+
+    //
+    // Shift all elements in argv which are present in args to the
+    // beginning of argv. We record the original value of argc so
+    // that we can know later if we've shifted the array.
+    //
+    const int argcOrig = argc;
+    int i = 0;
+    while(i < argc)
+    {
+        if(find(args.begin(), args.end(), wstringToString(argv[i], converter)) == args.end())
+        {
+            for(int j = i; j < argc - 1; j++)
+            {
+                argv[j] = argv[j + 1];
+            }
+            --argc;
+        }
+        else
+        {
+            ++i;
+        }
+    }
+
+    //
+    // Make sure that argv[argc] == 0, the ISO C++ standard requires this.
+    // We can only do this if we've shifted the array, otherwise argv[argc]
+    // may point to an invalid address.
+    //
+    if(argv && argcOrig != argc)
+    {
+        argv[argc] = 0;
+    }
+}
+#endif
+
 PropertiesPtr
 Ice::createProperties()
 {
-    return new PropertiesI(IceUtil::getProcessStringConverter());
+    return ICE_MAKE_SHARED(PropertiesI);
 }
 
 PropertiesPtr
 Ice::createProperties(StringSeq& args, const PropertiesPtr& defaults)
 {
-    return new PropertiesI(args, defaults, IceUtil::getProcessStringConverter());
+    return ICE_MAKE_SHARED(PropertiesI, args, defaults);
 }
 
 PropertiesPtr
-Ice::createProperties(int& argc, char* argv[], const PropertiesPtr& defaults)
+Ice::createProperties(int& argc, const char* argv[], const PropertiesPtr& defaults)
 {
     StringSeq args = argsToStringSeq(argc, argv);
     PropertiesPtr properties = createProperties(args, defaults);
@@ -153,6 +179,31 @@ Ice::createProperties(int& argc, char* argv[], const PropertiesPtr& defaults)
     return properties;
 }
 
+#ifdef _WIN32
+PropertiesPtr
+Ice::createProperties(int& argc, const wchar_t* argv[], const PropertiesPtr& defaults)
+{
+    StringSeq args = argsToStringSeq(argc, argv);
+    PropertiesPtr properties = createProperties(args, defaults);
+    stringSeqToArgs(args, argc, argv);
+    return properties;
+}
+#endif
+
+#ifdef ICE_CPP11_MAPPING
+Ice::ThreadHookPlugin::ThreadHookPlugin(const CommunicatorPtr& communicator,
+                                        function<void()> threadStart,
+                                        function<void()> threadStop)
+{
+    if(communicator == nullptr)
+    {
+        throw PluginInitializationException(__FILE__, __LINE__, "Communicator cannot be null");
+    }
+
+    IceInternal::InstancePtr instance = IceInternal::getInstance(communicator);
+    instance->setThreadHook(move(threadStart), move(threadStop));
+}
+#else
 Ice::ThreadHookPlugin::ThreadHookPlugin(const CommunicatorPtr& communicator, const ThreadNotificationPtr& threadHook)
 {
     if(communicator == 0)
@@ -163,7 +214,7 @@ Ice::ThreadHookPlugin::ThreadHookPlugin(const CommunicatorPtr& communicator, con
     IceInternal::InstancePtr instance = IceInternal::getInstance(communicator);
     instance->setThreadHook(threadHook);
 }
-
+#endif
 void
 Ice::ThreadHookPlugin::initialize()
 {
@@ -177,7 +228,7 @@ Ice::ThreadHookPlugin::destroy()
 namespace
 {
 
-inline void checkIceVersion(Int version)
+inline void checkIceVersion(int version)
 {
 #ifndef ICE_IGNORE_VERSION
 
@@ -222,32 +273,68 @@ inline void checkIceVersion(Int version)
 
 }
 
-CommunicatorPtr
-Ice::initialize(int& argc, char* argv[], const InitializationData& initializationData, Int version)
+Ice::CommunicatorPtr
+Ice::initialize(int& argc, const char* argv[], const InitializationData& initializationData, int version)
 {
     checkIceVersion(version);
 
     InitializationData initData = initializationData;
     initData.properties = createProperties(argc, argv, initData.properties);
 
-    CommunicatorI* communicatorI = new CommunicatorI(initData);
-    CommunicatorPtr result = communicatorI; // For exception safety.
-    communicatorI->finishSetup(argc, argv);
-    return result;
+    CommunicatorIPtr communicator = CommunicatorI::create(initData);
+    communicator->finishSetup(argc, argv);
+    return communicator;
+}
+
+Ice::CommunicatorPtr
+Ice::initialize(int& argc, const char* argv[], ICE_CONFIG_FILE_STRING configFile, int version)
+{
+    InitializationData initData;
+    initData.properties = createProperties();
+    initData.properties->load(configFile);
+    return initialize(argc, argv, initData, version);
 }
 
-CommunicatorPtr
-Ice::initialize(StringSeq& args, const InitializationData& initializationData, Int version)
+#ifdef _WIN32
+Ice::CommunicatorPtr
+Ice::initialize(int& argc, const wchar_t* argv[], const InitializationData& initializationData, int version)
 {
-    CommunicatorPtr communicator;
-    IceUtilInternal::ArgVector av(args);
-    communicator = initialize(av.argc, av.argv, initializationData, version);
+    Ice::StringSeq args = argsToStringSeq(argc, argv);
+    CommunicatorPtr communicator = initialize(args, initializationData, version);
+    stringSeqToArgs(args, argc, argv);
+    return communicator;
+}
+
+Ice::CommunicatorPtr
+Ice::initialize(int& argc, const wchar_t* argv[], ICE_CONFIG_FILE_STRING configFile, int version)
+{
+    InitializationData initData;
+    initData.properties = createProperties();
+    initData.properties->load(configFile);
+    return initialize(argc, argv, initData, version);
+}
+#endif
+
+Ice::CommunicatorPtr
+Ice::initialize(StringSeq& args, const InitializationData& initializationData, int version)
+{
+    IceInternal::ArgVector av(args);
+    CommunicatorPtr communicator = initialize(av.argc, av.argv, initializationData, version);
     args = argsToStringSeq(av.argc, av.argv);
     return communicator;
 }
 
-CommunicatorPtr
-Ice::initialize(const InitializationData& initData, Int version)
+Ice::CommunicatorPtr
+Ice::initialize(StringSeq& args, ICE_CONFIG_FILE_STRING configFile, int version)
+{
+    InitializationData initData;
+    initData.properties = createProperties();
+    initData.properties->load(configFile);
+    return initialize(args, initData, version);
+}
+
+Ice::CommunicatorPtr
+Ice::initialize(const InitializationData& initData, int version)
 {
     //
     // We can't simply call the other initialize() because this one does NOT read
@@ -255,196 +342,240 @@ Ice::initialize(const InitializationData& initData, Int version)
     //
     checkIceVersion(version);
 
-    CommunicatorI* communicatorI = new CommunicatorI(initData);
-    CommunicatorPtr result = communicatorI; // For exception safety.
+    CommunicatorIPtr communicator = CommunicatorI::create(initData);
     int argc = 0;
-    char* argv[] = { 0 };
-    communicatorI->finishSetup(argc, argv);
-    return result;
+    const char* argv[] = { 0 };
+    communicator->finishSetup(argc, argv);
+    return communicator;
 }
 
-InputStreamPtr
-Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes)
+Ice::CommunicatorPtr
+Ice::initialize(ICE_CONFIG_FILE_STRING configFile, int version)
 {
-    return new InputStreamI(communicator, makePair(bytes), true);
+    InitializationData initData;
+    initData.properties = createProperties();
+    initData.properties->load(configFile);
+    return initialize(initData, version);
 }
 
-InputStreamPtr
-Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, const EncodingVersion& v)
+LoggerPtr
+Ice::getProcessLogger()
 {
-    return new InputStreamI(communicator, makePair(bytes), v, true);
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+
+    if(processLogger == ICE_NULLPTR)
+    {
+       //
+       // TODO: Would be nice to be able to use process name as prefix by default.
+       //
+       processLogger = ICE_MAKE_SHARED(LoggerI, "", "", true);
+    }
+    return processLogger;
 }
 
-InputStreamPtr
-Ice::wrapInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes)
+void
+Ice::setProcessLogger(const LoggerPtr& logger)
 {
-    return new InputStreamI(communicator, makePair(bytes), false);
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+    processLogger = logger;
 }
 
-InputStreamPtr
-Ice::wrapInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, const EncodingVersion& v)
+void
+Ice::registerPluginFactory(const std::string& name, PluginFactory factory, bool loadOnInitialize)
 {
-    return new InputStreamI(communicator, makePair(bytes), v, false);
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+    PluginManagerI::registerPluginFactory(name, factory, loadOnInitialize);
 }
 
-InputStreamPtr
-Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes)
+//
+// CommunicatorHolder
+//
+
+Ice::CommunicatorHolder::CommunicatorHolder()
 {
-    return new InputStreamI(communicator, bytes, true);
 }
 
-InputStreamPtr
-Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
-                       const EncodingVersion& v)
+#ifdef ICE_CPP11_MAPPING
+Ice::CommunicatorHolder::CommunicatorHolder(shared_ptr<Communicator> communicator) :
+    _communicator(std::move(communicator))
 {
-    return new InputStreamI(communicator, bytes, v, true);
 }
 
-InputStreamPtr
-Ice::wrapInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes)
+Ice::CommunicatorHolder&
+Ice::CommunicatorHolder::operator=(shared_ptr<Communicator> communicator)
 {
-    return new InputStreamI(communicator, bytes, false);
+    if(_communicator)
+    {
+        _communicator->destroy();
+    }
+    _communicator = std::move(communicator);
+    return *this;
 }
 
-InputStreamPtr
-Ice::wrapInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
-                     const EncodingVersion& v)
+Ice::CommunicatorHolder&
+Ice::CommunicatorHolder::operator=(CommunicatorHolder&& other) noexcept
 {
-    return new InputStreamI(communicator, bytes, v, false);
+    if(_communicator)
+    {
+        _communicator->destroy();
+    }
+    _communicator = std::move(other._communicator);
+    return *this;
 }
 
-OutputStreamPtr
-Ice::createOutputStream(const CommunicatorPtr& communicator)
+#else // C++98 mapping
+
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, const char* argv[], const InitializationData& initData,
+                                            int version) :
+    _communicator(initialize(argc, argv, initData, version))
 {
-    return new OutputStreamI(communicator);
 }
 
-OutputStreamPtr
-Ice::createOutputStream(const CommunicatorPtr& communicator, const EncodingVersion& v)
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, char* argv[], const InitializationData& initData, int version) :
+    _communicator(initialize(argc, argv, initData, version))
 {
-    return new OutputStreamI(communicator, v);
 }
 
-LoggerPtr
-Ice::getProcessLogger()
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, const char* argv[], const char* configFile, int version) :
+    _communicator(initialize(argc, argv, configFile, version))
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+}
 
-    if(processLogger == 0)
-    {
-       //
-       // TODO: Would be nice to be able to use process name as prefix by default.
-       //
-       processLogger = new Ice::LoggerI("", "", true, IceUtil::getProcessStringConverter());
-    }
-    return processLogger;
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, char* argv[], const char* configFile, int version) :
+    _communicator(initialize(argc, argv, configFile, version))
+{
 }
 
-void
-Ice::setProcessLogger(const LoggerPtr& logger)
+#   ifdef _WIN32
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, const wchar_t* argv[], const InitializationData& initData,
+                                            int version) :
+    _communicator(initialize(argc, argv, initData, version))
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
-    processLogger = logger;
 }
 
-void
-Ice::registerPluginFactory(const std::string& name, PLUGIN_FACTORY factory, bool loadOnInitialize)
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, wchar_t* argv[], const InitializationData& initData,
+                                            int version) :
+    _communicator(initialize(argc, argv, initData, version))
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
-    PluginManagerI::registerPluginFactory(name, factory, loadOnInitialize);
 }
 
-InstancePtr
-IceInternal::getInstance(const CommunicatorPtr& communicator)
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, const wchar_t* argv[], const char* configFile, int version) :
+    _communicator(initialize(argc, argv, configFile, version))
 {
-    CommunicatorI* p = dynamic_cast<CommunicatorI*>(communicator.get());
-    assert(p);
-    return p->_instance;
 }
 
-IceUtil::TimerPtr
-IceInternal::getInstanceTimer(const CommunicatorPtr& communicator)
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, wchar_t* argv[], const char* configFile, int version) :
+    _communicator(initialize(argc, argv, configFile, version))
 {
-    CommunicatorI* p = dynamic_cast<CommunicatorI*>(communicator.get());
-    assert(p);
-    return p->_instance->timer();
 }
+#   endif
 
-#ifdef ICE_CPP11
-Ice::DispatcherPtr
-Ice::newDispatcher(const ::std::function<void (const DispatcherCallPtr&, const ConnectionPtr)>& cb)
+Ice::CommunicatorHolder::CommunicatorHolder(StringSeq& args, const InitializationData& initData, int version) :
+    _communicator(initialize(args, initData, version))
 {
-    class Cpp11Dispatcher : public Dispatcher
-    {
-    public:
+}
 
-        Cpp11Dispatcher(const ::std::function<void (const DispatcherCallPtr&, const ConnectionPtr)>& cb) :
-            _cb(cb)
-        {
-        }
+Ice::CommunicatorHolder::CommunicatorHolder(StringSeq& args, const char* configFile, int version) :
+    _communicator(initialize(args, configFile, version))
+{
+}
 
-        virtual void dispatch(const DispatcherCallPtr& call, const ConnectionPtr& conn)
-        {
-            _cb(call, conn);
-        }
+Ice::CommunicatorHolder::CommunicatorHolder(const InitializationData& initData, int version) :
+    _communicator(initialize(initData, version))
+{
+}
 
-    private:
-        const ::std::function<void (const DispatcherCallPtr&, const ConnectionPtr)> _cb;
-    };
+Ice::CommunicatorHolder::CommunicatorHolder(const char* configFile, int version) :
+    _communicator(initialize(configFile, version))
+{
+}
 
-    return new Cpp11Dispatcher(cb);
+Ice::CommunicatorHolder::CommunicatorHolder(const CommunicatorPtr& communicator) :
+    _communicator(communicator)
+{
 }
-#endif
 
-#ifdef ICE_CPP11
-Ice::BatchRequestInterceptorPtr
-Ice::newBatchRequestInterceptor(const ::std::function<void (const BatchRequest&, int, int)>& cb)
+Ice::CommunicatorHolder&
+Ice::CommunicatorHolder::operator=(const CommunicatorPtr& communicator)
 {
-    class Cpp11BatchRequestInterceptor : public BatchRequestInterceptor
+    if(_communicator)
     {
-    public:
+        _communicator->destroy();
+    }
+    _communicator = communicator;
+    return *this;
+}
 
-        Cpp11BatchRequestInterceptor(const ::std::function<void (const BatchRequest&, int, int)>& cb) :
-            _cb(cb)
-        {
-        }
+#endif
 
-        virtual void enqueue(const BatchRequest& request, int count, int size)
-        {
-            _cb(request, count, size);
-        }
+Ice::CommunicatorHolder::~CommunicatorHolder()
+{
+    if(_communicator)
+    {
+        _communicator->destroy();
+    }
+}
+
+Ice::CommunicatorHolder::operator bool() const
+{
+    return _communicator != ICE_NULLPTR;
+}
 
-    private:
-        const ::std::function<void (const BatchRequest&, int, int)> _cb;
-    };
+const Ice::CommunicatorPtr&
+Ice::CommunicatorHolder::communicator() const
+{
+    return _communicator;
+}
 
-    return new Cpp11BatchRequestInterceptor(cb);
+const Ice::CommunicatorPtr&
+Ice::CommunicatorHolder::operator->() const
+{
+    return _communicator;
 }
+
+Ice::CommunicatorPtr
+Ice::CommunicatorHolder::release()
+{
+#ifdef ICE_CPP11_MAPPING
+    return std::move(_communicator);
+#else
+    CommunicatorPtr result;
+    result.swap(_communicator);
+    return result;
 #endif
+}
+
+InstancePtr
+IceInternal::getInstance(const CommunicatorPtr& communicator)
+{
+    CommunicatorIPtr p = ICE_DYNAMIC_CAST(::Ice::CommunicatorI, communicator);
+    assert(p);
+    return p->_instance;
+}
+
+IceUtil::TimerPtr
+IceInternal::getInstanceTimer(const CommunicatorPtr& communicator)
+{
+    CommunicatorIPtr p = ICE_DYNAMIC_CAST(::Ice::CommunicatorI, communicator);
+    assert(p);
+    return p->_instance->timer();
+}
 
 Identity
 Ice::stringToIdentity(const string& s)
 {
-    //
-    // 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;
+    string::size_type slash = string::npos;
+    string::size_type pos = 0;
     while((pos = s.find('/', pos)) != string::npos)
     {
-        int escapes = 0;
-        while(static_cast<int>(pos)- escapes > 0 && s[pos - escapes - 1] == '\\')
+        string::size_type escapes = 0;
+        while(static_cast<int>(pos - escapes) > 0 && s[pos - escapes - 1] == '\\')
         {
             escapes++;
         }
@@ -463,9 +594,7 @@ Ice::stringToIdentity(const string& s)
                 //
                 // Extra unescaped slash found.
                 //
-                IdentityParseException ex(__FILE__, __LINE__);
-                ex.str = "unescaped backslash in identity `" + s + "'";
-                throw ex;
+                throw IdentityParseException(__FILE__, __LINE__, "unescaped '/' in identity `" + s + "'");
             }
         }
         pos++;
@@ -475,64 +604,51 @@ Ice::stringToIdentity(const string& s)
     {
         try
         {
-            ident.name = IceUtilInternal::unescapeString(s, 0, s.size());
+            ident.name = unescapeString(s, 0, s.size(), "/");
         }
-        catch(const IceUtil::IllegalArgumentException& e)
+        catch(const IceUtil::IllegalArgumentException& ex)
         {
-            IdentityParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid identity name `" + s + "': " + e.reason();
-            throw ex;
+            throw IdentityParseException(__FILE__, __LINE__, "invalid identity name `" + s + "': " + ex.reason());
         }
     }
     else
     {
         try
         {
-            ident.category = IceUtilInternal::unescapeString(s, 0, slash);
+            ident.category = unescapeString(s, 0, slash, "/");
         }
-        catch(const IceUtil::IllegalArgumentException& e)
+        catch(const IceUtil::IllegalArgumentException& ex)
         {
-            IdentityParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid category in identity `" + s + "': " + e.reason();
-            throw ex;
+            throw IdentityParseException(__FILE__, __LINE__, "invalid category in identity `" + s + "': " +
+                                         ex.reason());
         }
+
         if(slash + 1 < s.size())
         {
             try
             {
-                ident.name = IceUtilInternal::unescapeString(s, slash + 1, s.size());
+                ident.name = unescapeString(s, slash + 1, s.size(), "/");
             }
-            catch(const IceUtil::IllegalArgumentException& e)
+            catch(const IceUtil::IllegalArgumentException& ex)
             {
-                IdentityParseException ex(__FILE__, __LINE__);
-                ex.str = "invalid name in identity `" + s + "': " + e.reason();
-                throw ex;
+                throw IdentityParseException(__FILE__, __LINE__, "invalid name in identity `" + s + "': " +
+                                             ex.reason());
             }
         }
     }
 
-    ident.name = UTF8ToNative(ident.name, IceUtil::getProcessStringConverter());
-    ident.category = UTF8ToNative(ident.category, IceUtil::getProcessStringConverter());
-
     return ident;
 }
 
 string
-Ice::identityToString(const Identity& ident)
+Ice::identityToString(const Identity& ident, ToStringMode toStringMode)
 {
-    //
-    // 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, IceUtil::getProcessStringConverter());
-    string category = nativeToUTF8(ident.category, IceUtil::getProcessStringConverter());
-
-    if(category.empty())
+    if(ident.category.empty())
     {
-        return IceUtilInternal::escapeString(name, "/");
+        return escapeString(ident.name, "/", toStringMode);
     }
     else
     {
-        return IceUtilInternal::escapeString(category, "/") + '/' + IceUtilInternal::escapeString(name, "/");
+        return escapeString(ident.category, "/", toStringMode) + '/' + escapeString(ident.name, "/", toStringMode);
     }
 }