zeroc-ice 3.6.5 → 3.7.0

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

@@ -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.
@@ -15,7 +15,7 @@
 
 #include <Ice/RequestHandler.h>
 #include <Ice/ResponseHandler.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
 #include <Ice/ObjectAdapterF.h>
 #include <Ice/LoggerF.h>
 #include <Ice/TraceLevelsF.h>
@@ -24,19 +24,19 @@ namespace Ice
 {
 
 class ObjectAdapterI;
-typedef IceUtil::Handle<ObjectAdapterI> ObjectAdapterIPtr;
+ICE_DEFINE_PTR(ObjectAdapterIPtr, ObjectAdapterI);
 
 }
 
 namespace IceInternal
 {
 
-class OutgoingBase;
-class Outgoing;
 class OutgoingAsyncBase;
 class OutgoingAsync;
 
-class CollocatedRequestHandler : public RequestHandler, public ResponseHandler, private IceUtil::Monitor<IceUtil::Mutex>
+class CollocatedRequestHandler : public RequestHandler,
+                                 public ResponseHandler,
+                                 private IceUtil::Monitor<IceUtil::Mutex>
 {
 public:
 
@@ -45,13 +45,11 @@ public:
 
     virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&);
 
-    virtual bool sendRequest(ProxyOutgoingBase*);
     virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&);
 
-    virtual void requestCanceled(OutgoingBase*, const Ice::LocalException&);
     virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&);
 
-    virtual void sendResponse(Ice::Int, BasicStream*, Ice::Byte, bool);
+    virtual void sendResponse(Ice::Int, Ice::OutputStream*, Ice::Byte, bool);
     virtual void sendNoResponse();
     virtual bool systemException(Ice::Int, const Ice::SystemException&, bool);
     virtual void invokeException(Ice::Int, const Ice::LocalException&, int, bool);
@@ -61,13 +59,18 @@ public:
     virtual Ice::ConnectionIPtr getConnection();
     virtual Ice::ConnectionIPtr waitForConnection();
 
-    void invokeRequest(OutgoingBase*, int);
-    AsyncStatus invokeAsyncRequest(OutgoingAsyncBase*, int);
+    AsyncStatus invokeAsyncRequest(OutgoingAsyncBase*, int, bool);
 
-    bool sent(OutgoingBase*);
     bool sentAsync(OutgoingAsyncBase*);
 
-    void invokeAll(BasicStream*, Ice::Int, Ice::Int);
+    void invokeAll(Ice::OutputStream*, Ice::Int, Ice::Int);
+
+#ifdef ICE_CPP11_MAPPING
+    std::shared_ptr<CollocatedRequestHandler> shared_from_this()
+    {
+        return std::static_pointer_cast<CollocatedRequestHandler>(ResponseHandler::shared_from_this());
+    }
+#endif
 
 private:
 
@@ -79,14 +82,10 @@ private:
     const TraceLevelsPtr _traceLevels;
 
     int _requestId;
-
-    std::map<OutgoingBase*, Ice::Int> _sendRequests;
     std::map<OutgoingAsyncBasePtr, Ice::Int> _sendAsyncRequests;
-
-    std::map<Ice::Int, OutgoingBase*> _requests;
     std::map<Ice::Int, OutgoingAsyncBasePtr> _asyncRequests;
 };
-typedef IceUtil::Handle<CollocatedRequestHandler> CollocatedRequestHandlerPtr;
+ICE_DEFINE_PTR(CollocatedRequestHandlerPtr, CollocatedRequestHandler);
 
 }
 

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

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 //
-// Ice version 3.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
@@ -24,28 +24,59 @@
 #include <Ice/Communicator.h>
 #include <IceUtil/PushDisableWarnings.h>
 #include <Ice/LocalException.h>
-#include <Ice/ObjectFactory.h>
-#include <Ice/Outgoing.h>
+#include <Ice/ValueFactory.h>
 #include <Ice/OutgoingAsync.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/LocalException.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 > 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
 namespace
 {
 
 }
 
+Ice::Communicator::~Communicator()
+{
+}
+
+#else // C++98 mapping
+
+namespace
+{
+
+}
+
+Ice::Communicator::~Communicator()
+{
+}
+
 ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::Communicator* p) { return p; }
+
+namespace Ice
+{
+}
+
+#endif

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

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 //
-// Ice version 3.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
@@ -23,22 +23,44 @@
 #endif
 #include <Ice/CommunicatorF.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <IceUtil/Iterator.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 > 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
+namespace
+{
+
+}
+
+#else // C++98 mapping
+
 namespace
 {
 
 }
+
+namespace Ice
+{
+}
+
+#endif

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

@@ -1,19 +1,19 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 
+#include <IceUtil/DisableWarnings.h>
 #include <Ice/CommunicatorI.h>
 #include <Ice/Instance.h>
 #include <Ice/Properties.h>
 #include <Ice/ConnectionFactory.h>
 #include <Ice/ReferenceFactory.h>
 #include <Ice/ProxyFactory.h>
-#include <Ice/ObjectFactoryManager.h>
 #include <Ice/ObjectAdapterFactory.h>
 #include <Ice/LoggerUtil.h>
 #include <Ice/LocalException.h>
@@ -23,14 +23,176 @@
 #include <Ice/OutgoingAsync.h>
 #include <IceUtil/Mutex.h>
 #include <IceUtil/MutexPtrLock.h>
-#include <IceUtil/UUID.h>
+#include <Ice/UUID.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+#ifndef ICE_CPP11_MAPPING
+IceUtil::Shared* IceInternal::upCast(CommunicatorFlushBatchAsync* p) { return p; }
+#endif
+
+CommunicatorFlushBatchAsync::~CommunicatorFlushBatchAsync()
+{
+    // Out of line to avoid weak vtable
+}
+
+CommunicatorFlushBatchAsync::CommunicatorFlushBatchAsync(const InstancePtr& instance) :
+    OutgoingAsyncBase(instance)
+{
+    //
+    // _useCount is initialized to 1 to prevent premature callbacks.
+    // The caller must invoke ready() after all flush requests have
+    // been initiated.
+    //
+    _useCount = 1;
+}
+
+void
+CommunicatorFlushBatchAsync::flushConnection(const ConnectionIPtr& con, Ice::CompressBatch compressBatch)
+{
+    class FlushBatch : public OutgoingAsyncBase
+    {
+    public:
+
+        FlushBatch(const CommunicatorFlushBatchAsyncPtr& outAsync,
+                   const InstancePtr& instance,
+                   InvocationObserver& observer) :
+            OutgoingAsyncBase(instance), _outAsync(outAsync), _observer(observer)
+        {
+        }
+
+        virtual bool
+        sent()
+        {
+            _childObserver.detach();
+            _outAsync->check(false);
+            return false;
+        }
+
+        virtual bool
+        exception(const Exception& ex)
+        {
+            _childObserver.failed(ex.ice_id());
+            _childObserver.detach();
+            _outAsync->check(false);
+            return false;
+        }
+
+        virtual InvocationObserver&
+        getObserver()
+        {
+            return _observer;
+        }
+
+        virtual bool handleSent(bool, bool)
+        {
+            return false;
+        }
+
+        virtual bool handleException(const Ice::Exception&)
+        {
+            return false;
+        }
+
+        virtual bool handleResponse(bool)
+        {
+            return false;
+        }
+
+        virtual void handleInvokeSent(bool, OutgoingAsyncBase*) const
+        {
+            assert(false);
+        }
+
+        virtual void handleInvokeException(const Ice::Exception&, OutgoingAsyncBase*) const
+        {
+            assert(false);
+        }
+
+        virtual void handleInvokeResponse(bool, OutgoingAsyncBase*) const
+        {
+            assert(false);
+        }
+
+    private:
+
+        const CommunicatorFlushBatchAsyncPtr _outAsync;
+        InvocationObserver& _observer;
+    };
+
+    {
+        Lock sync(_m);
+        ++_useCount;
+    }
+
+    try
+    {
+        OutgoingAsyncBasePtr flushBatch = ICE_MAKE_SHARED(FlushBatch, ICE_SHARED_FROM_THIS, _instance, _observer);
+        bool compress;
+        int batchRequestNum = con->getBatchRequestQueue()->swap(flushBatch->getOs(), compress);
+        if(batchRequestNum == 0)
+        {
+            flushBatch->sent();
+        }
+        else
+        {
+            if(compressBatch == ICE_SCOPED_ENUM(CompressBatch, Yes))
+            {
+                compress = true;
+            }
+            else if(compressBatch == ICE_SCOPED_ENUM(CompressBatch, No))
+            {
+                compress = false;
+            }
+            con->sendAsyncRequest(flushBatch, compress, false, batchRequestNum);
+        }
+    }
+    catch(const LocalException&)
+    {
+        check(false);
+        throw;
+    }
+}
+
+void
+CommunicatorFlushBatchAsync::invoke(const string& operation, CompressBatch compressBatch)
+{
+    _observer.attach(_instance.get(), operation);
+    _instance->outgoingConnectionFactory()->flushAsyncBatchRequests(ICE_SHARED_FROM_THIS, compressBatch);
+    _instance->objectAdapterFactory()->flushAsyncBatchRequests(ICE_SHARED_FROM_THIS, compressBatch);
+    check(true);
+}
+
+void
+CommunicatorFlushBatchAsync::check(bool userThread)
+{
+    {
+        Lock sync(_m);
+        assert(_useCount > 0);
+        if(--_useCount > 0)
+        {
+            return;
+        }
+    }
+
+    if(sentImpl(true))
+    {
+        if(userThread)
+        {
+            _sentSynchronously = true;
+            invokeSent();
+        }
+        else
+        {
+            invokeSentAsync();
+        }
+    }
+}
+
 void
-Ice::CommunicatorI::destroy()
+Ice::CommunicatorI::destroy() ICE_NOEXCEPT
 {
     if(_instance)
     {
@@ -56,26 +218,26 @@ Ice::CommunicatorI::isShutdown() const
     return _instance->objectAdapterFactory()->isShutdown();
 }
 
-ObjectPrx
+ObjectPrxPtr
 Ice::CommunicatorI::stringToProxy(const string& s) const
 {
     return _instance->proxyFactory()->stringToProxy(s);
 }
 
 string
-Ice::CommunicatorI::proxyToString(const ObjectPrx& proxy) const
+Ice::CommunicatorI::proxyToString(const ObjectPrxPtr& proxy) const
 {
     return _instance->proxyFactory()->proxyToString(proxy);
 }
 
-ObjectPrx
+ObjectPrxPtr
 Ice::CommunicatorI::propertyToProxy(const string& p) const
 {
     return _instance->proxyFactory()->propertyToProxy(p);
 }
 
 PropertyDict
-Ice::CommunicatorI::proxyToProperty(const ObjectPrx& proxy, const string& property) const
+Ice::CommunicatorI::proxyToProperty(const ObjectPrxPtr& proxy, const string& property) const
 {
     return _instance->proxyFactory()->proxyToProperty(proxy, property);
 }
@@ -83,19 +245,19 @@ Ice::CommunicatorI::proxyToProperty(const ObjectPrx& proxy, const string& proper
 Identity
 Ice::CommunicatorI::stringToIdentity(const string& s) const
 {
-    return _instance->stringToIdentity(s);
+    return Ice::stringToIdentity(s);
 }
 
 string
 Ice::CommunicatorI::identityToString(const Identity& ident) const
 {
-    return _instance->identityToString(ident);
+    return Ice::identityToString(ident, _instance->toStringMode());
 }
 
 ObjectAdapterPtr
 Ice::CommunicatorI::createObjectAdapter(const string& name)
 {
-    return _instance->objectAdapterFactory()->createObjectAdapter(name, 0);
+    return _instance->objectAdapterFactory()->createObjectAdapter(name, ICE_NULLPTR);
 }
 
 ObjectAdapterPtr
@@ -104,20 +266,20 @@ Ice::CommunicatorI::createObjectAdapterWithEndpoints(const string& name, const s
     string oaName = name;
     if(oaName.empty())
     {
-        oaName = IceUtil::generateUUID();
+        oaName = Ice::generateUUID();
     }
 
     getProperties()->setProperty(oaName + ".Endpoints", endpoints);
-    return _instance->objectAdapterFactory()->createObjectAdapter(oaName, 0);
+    return _instance->objectAdapterFactory()->createObjectAdapter(oaName, ICE_NULLPTR);
 }
 
 ObjectAdapterPtr
-Ice::CommunicatorI::createObjectAdapterWithRouter(const string& name, const RouterPrx& router)
+Ice::CommunicatorI::createObjectAdapterWithRouter(const string& name, const RouterPrxPtr& router)
 {
     string oaName = name;
     if(oaName.empty())
     {
-        oaName = IceUtil::generateUUID();
+        oaName = Ice::generateUUID();
     }
 
     PropertyDict properties = proxyToProperty(router, oaName + ".Router");
@@ -130,15 +292,15 @@ Ice::CommunicatorI::createObjectAdapterWithRouter(const string& name, const Rout
 }
 
 void
-Ice::CommunicatorI::addObjectFactory(const ObjectFactoryPtr& factory, const string& id)
+Ice::CommunicatorI::addObjectFactory(const ::Ice::ObjectFactoryPtr& factory, const string& id)
 {
-    _instance->servantFactoryManager()->add(factory, id);
+    _instance->addObjectFactory(factory, id);
 }
 
-ObjectFactoryPtr
+::Ice::ObjectFactoryPtr
 Ice::CommunicatorI::findObjectFactory(const string& id) const
 {
-    return _instance->servantFactoryManager()->find(id);
+    return _instance->findObjectFactory(id);
 }
 
 PropertiesPtr
@@ -159,26 +321,26 @@ Ice::CommunicatorI::getObserver() const
     return _instance->initializationData().observer;
 }
 
-RouterPrx
+RouterPrxPtr
 Ice::CommunicatorI::getDefaultRouter() const
 {
     return _instance->referenceFactory()->getDefaultRouter();
 }
 
 void
-Ice::CommunicatorI::setDefaultRouter(const RouterPrx& router)
+Ice::CommunicatorI::setDefaultRouter(const RouterPrxPtr& router)
 {
     _instance->setDefaultRouter(router);
 }
 
-LocatorPrx
+LocatorPrxPtr
 Ice::CommunicatorI::getDefaultLocator() const
 {
     return _instance->referenceFactory()->getDefaultLocator();
 }
 
 void
-Ice::CommunicatorI::setDefaultLocator(const LocatorPrx& locator)
+Ice::CommunicatorI::setDefaultLocator(const LocatorPrxPtr& locator)
 {
     _instance->setDefaultLocator(locator);
 }
@@ -195,120 +357,125 @@ Ice::CommunicatorI::getPluginManager() const
     return _instance->pluginManager();
 }
 
+ValueFactoryManagerPtr
+Ice::CommunicatorI::getValueFactoryManager() const
+{
+    return _instance->initializationData().valueFactoryManager;
+}
+
+namespace
+{
+
+const ::std::string flushBatchRequests_name = "flushBatchRequests";
+
+}
+
+#ifdef ICE_CPP11_MAPPING
+
+::std::function<void()>
+Ice::CommunicatorI::flushBatchRequestsAsync(CompressBatch compress,
+                                            function<void(exception_ptr)> ex,
+                                            function<void(bool)> sent)
+{
+    class CommunicatorFlushBatchLambda : public CommunicatorFlushBatchAsync, public LambdaInvoke
+    {
+    public:
+
+        CommunicatorFlushBatchLambda(const InstancePtr& instance,
+                                     std::function<void(std::exception_ptr)> ex,
+                                     std::function<void(bool)> sent) :
+            CommunicatorFlushBatchAsync(instance), LambdaInvoke(std::move(ex), std::move(sent))
+        {
+        }
+    };
+    auto outAsync = make_shared<CommunicatorFlushBatchLambda>(_instance, ex, sent);
+    outAsync->invoke(flushBatchRequests_name, compress);
+    return [outAsync]() { outAsync->cancel(); };
+}
+
+#else
+
 void
-Ice::CommunicatorI::flushBatchRequests()
+Ice::CommunicatorI::flushBatchRequests(CompressBatch compress)
 {
-    end_flushBatchRequests(begin_flushBatchRequests());
+    end_flushBatchRequests(begin_flushBatchRequests(compress));
 }
 
 AsyncResultPtr
-Ice::CommunicatorI::begin_flushBatchRequests()
+Ice::CommunicatorI::begin_flushBatchRequests(CompressBatch compress)
 {
-    return __begin_flushBatchRequests(::IceInternal::__dummyCallback, 0);
+    return _iceI_begin_flushBatchRequests(compress, ::IceInternal::dummyCallback, 0);
 }
 
 AsyncResultPtr
-Ice::CommunicatorI::begin_flushBatchRequests(const CallbackPtr& cb, const LocalObjectPtr& cookie)
+Ice::CommunicatorI::begin_flushBatchRequests(CompressBatch compress,
+                                             const CallbackPtr& cb,
+                                             const LocalObjectPtr& cookie)
 {
-    return __begin_flushBatchRequests(cb, cookie);
+    return _iceI_begin_flushBatchRequests(compress, cb, cookie);
 }
 
 AsyncResultPtr
-Ice::CommunicatorI::begin_flushBatchRequests(const Callback_Communicator_flushBatchRequestsPtr& cb,
+Ice::CommunicatorI::begin_flushBatchRequests(CompressBatch compress,
+                                             const Callback_Communicator_flushBatchRequestsPtr& cb,
                                              const LocalObjectPtr& cookie)
 {
-    return __begin_flushBatchRequests(cb, cookie);
+    return _iceI_begin_flushBatchRequests(compress, cb, cookie);
 }
 
 AsyncResultPtr
-Ice::CommunicatorI::begin_flushBatchRequests(const IceInternal::Function<void (const Exception&)>& exception,
-                                             const IceInternal::Function<void (bool)>& sent)
+Ice::CommunicatorI::_iceI_begin_flushBatchRequests(CompressBatch compress,
+                                                   const IceInternal::CallbackBasePtr& cb,
+                                                   const LocalObjectPtr& cookie)
 {
-#ifdef ICE_CPP11
-    class Cpp11CB : public IceInternal::Cpp11FnCallbackNC
+    class CommunicatorFlushBatchAsyncWithCallback : public CommunicatorFlushBatchAsync, public CallbackCompletion
     {
-
     public:
 
-        Cpp11CB(const IceInternal::Function<void (const Exception&)>& excb,
-                const IceInternal::Function<void (bool)>& sentcb) :
-            IceInternal::Cpp11FnCallbackNC(excb, sentcb)
+        CommunicatorFlushBatchAsyncWithCallback(const Ice::CommunicatorPtr& communicator,
+                                                const InstancePtr& instance,
+                                                const CallbackBasePtr& callback,
+                                                const Ice::LocalObjectPtr& cookie) :
+            CommunicatorFlushBatchAsync(instance), CallbackCompletion(callback, cookie), _communicator(communicator)
         {
-            CallbackBase::checkCallback(true, excb != nullptr);
+            _cookie = cookie;
         }
 
-        virtual void
-        completed(const AsyncResultPtr& __result) const
+        virtual Ice::CommunicatorPtr getCommunicator() const
         {
-            CommunicatorPtr __com = __result->getCommunicator();
-            assert(__com);
-            try
-            {
-                __com->end_flushBatchRequests(__result);
-                assert(false);
-            }
-            catch(const Exception& ex)
-            {
-                IceInternal::Cpp11FnCallbackNC::exception(__result, ex);
-            }
+            return _communicator;
         }
-    };
-
-    return __begin_flushBatchRequests(new Cpp11CB(exception, sent), 0);
-#else
-    assert(false); // Ice not built with C++11 support.
-    return 0;
-#endif
-}
-
-namespace
-{
-
-const ::std::string __flushBatchRequests_name = "flushBatchRequests";
-
-}
 
-AsyncResultPtr
-Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePtr& cb, const LocalObjectPtr& cookie)
-{
-    OutgoingConnectionFactoryPtr connectionFactory = _instance->outgoingConnectionFactory();
-    ObjectAdapterFactoryPtr adapterFactory = _instance->objectAdapterFactory();
-
-    //
-    // This callback object receives the results of all invocations
-    // of Connection::begin_flushBatchRequests.
-    //
-    CommunicatorFlushBatchAsyncPtr result = new CommunicatorFlushBatchAsync(this,
-                                                                            _instance,
-                                                                            __flushBatchRequests_name,
-                                                                            cb,
-                                                                            cookie);
+        virtual const std::string&
+        getOperation() const
+        {
+            return flushBatchRequests_name;
+        }
 
-    connectionFactory->flushAsyncBatchRequests(result);
-    adapterFactory->flushAsyncBatchRequests(result);
+    private:
 
-    //
-    // Inform the callback that we have finished initiating all of the
-    // flush requests.
-    //
-    result->ready();
+        Ice::CommunicatorPtr _communicator;
+    };
 
+    CommunicatorFlushBatchAsyncPtr result = new CommunicatorFlushBatchAsyncWithCallback(this, _instance, cb, cookie);
+    result->invoke(flushBatchRequests_name, compress);
     return result;
 }
 
 void
 Ice::CommunicatorI::end_flushBatchRequests(const AsyncResultPtr& r)
 {
-    AsyncResult::__check(r, this, __flushBatchRequests_name);
-    r->__wait();
+    AsyncResult::_check(r, this, flushBatchRequests_name);
+    r->_waitForResponse();
 }
+#endif
 
-ObjectPrx
+ObjectPrxPtr
 Ice::CommunicatorI::createAdmin(const ObjectAdapterPtr& adminAdapter, const Identity& adminId)
 {
     return _instance->createAdmin(adminAdapter, adminId);
 }
-ObjectPrx
+ObjectPrxPtr
 Ice::CommunicatorI::getAdmin() const
 {
     return _instance->getAdmin();
@@ -338,32 +505,32 @@ Ice::CommunicatorI::findAllAdminFacets()
     return _instance->findAllAdminFacets();
 }
 
-Ice::CommunicatorI::CommunicatorI(const InitializationData& initData)
+CommunicatorIPtr
+Ice::CommunicatorI::create(const InitializationData& initData)
 {
-    __setNoDelete(true);
+    Ice::CommunicatorIPtr communicator = ICE_MAKE_SHARED(CommunicatorI);
     try
     {
-        const_cast<InstancePtr&>(_instance) = new Instance(this, initData);
+        const_cast<InstancePtr&>(communicator->_instance) = new Instance(communicator, initData);
 
         //
         // Keep a reference to the dynamic library list to ensure
         // the libraries are not unloaded until this Communicator's
         // destructor is invoked.
         //
-        const_cast<DynamicLibraryListPtr&>(_dynamicLibraryList) = _instance->dynamicLibraryList();
+        const_cast<DynamicLibraryListPtr&>(communicator->_dynamicLibraryList) = communicator->_instance->dynamicLibraryList();
     }
     catch(...)
     {
-        destroy();
-        __setNoDelete(false);
+        communicator->destroy();
         throw;
     }
-    __setNoDelete(false);
+    return communicator;
 }
 
 Ice::CommunicatorI::~CommunicatorI()
 {
-    if(!_instance->destroyed())
+    if(_instance && !_instance->destroyed())
     {
         Warning out(_instance->initializationData().logger);
         out << "Ice::Communicator::destroy() has not been called";
@@ -371,11 +538,11 @@ Ice::CommunicatorI::~CommunicatorI()
 }
 
 void
-Ice::CommunicatorI::finishSetup(int& argc, char* argv[])
+Ice::CommunicatorI::finishSetup(int& argc, const char* argv[])
 {
     try
     {
-        _instance->finishSetup(argc, argv, this);
+        _instance->finishSetup(argc, argv, ICE_SHARED_FROM_THIS);
     }
     catch(...)
     {