zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Ice/CommunicatorI.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.
@@ -16,31 +16,73 @@
 #include <Ice/Initialize.h>
 #include <Ice/Communicator.h>
 #include <Ice/CommunicatorAsync.h>
+#include <Ice/OutgoingAsync.h>
+
+namespace IceInternal
+{
+
+//
+// Class for handling Ice::Communicator::begin_flushBatchRequests
+//
+class CommunicatorFlushBatchAsync : public OutgoingAsyncBase
+{
+public:
+
+    virtual ~CommunicatorFlushBatchAsync();
+
+    CommunicatorFlushBatchAsync(const InstancePtr&);
+
+    void flushConnection(const Ice::ConnectionIPtr&, Ice::CompressBatch);
+    void invoke(const std::string&, Ice::CompressBatch);
+
+#ifdef ICE_CPP11_MAPPING
+    std::shared_ptr<CommunicatorFlushBatchAsync> shared_from_this()
+    {
+        return std::static_pointer_cast<CommunicatorFlushBatchAsync>(OutgoingAsyncBase::shared_from_this());
+    }
+#endif
+
+private:
+
+    void check(bool);
+
+    int _useCount;
+    InvocationObserver _observer;
+};
+
+}
 
 namespace Ice
 {
 
+class CommunicatorI;
+ICE_DEFINE_PTR(CommunicatorIPtr, CommunicatorI);
+
 class CommunicatorI : public Communicator
+#ifdef ICE_CPP11_MAPPING
+                    , public std::enable_shared_from_this<CommunicatorI>
+#endif
+
 {
 public:
-    
-    virtual void destroy();
+
+    virtual void destroy() ICE_NOEXCEPT;
     virtual void shutdown();
     virtual void waitForShutdown();
     virtual bool isShutdown() const;
 
-    virtual ObjectPrx stringToProxy(const std::string&) const;
-    virtual std::string proxyToString(const ObjectPrx&) const;
+    virtual ObjectPrxPtr stringToProxy(const std::string&) const;
+    virtual std::string proxyToString(const ObjectPrxPtr&) const;
 
-    virtual ObjectPrx propertyToProxy(const std::string&) const;
-    virtual PropertyDict proxyToProperty(const ObjectPrx&, const std::string&) const;
+    virtual ObjectPrxPtr propertyToProxy(const std::string&) const;
+    virtual PropertyDict proxyToProperty(const ObjectPrxPtr&, const std::string&) const;
 
     virtual Identity stringToIdentity(const std::string&) const;
     virtual std::string identityToString(const Identity&) const;
 
     virtual ObjectAdapterPtr createObjectAdapter(const std::string&);
     virtual ObjectAdapterPtr createObjectAdapterWithEndpoints(const std::string&, const std::string&);
-    virtual ObjectAdapterPtr createObjectAdapterWithRouter(const std::string&, const RouterPrx&);
+    virtual ObjectAdapterPtr createObjectAdapterWithRouter(const std::string&, const RouterPrxPtr&);
 
     virtual void addObjectFactory(const ObjectFactoryPtr&, const std::string&);
     virtual ObjectFactoryPtr findObjectFactory(const std::string&) const;
@@ -51,52 +93,66 @@ public:
     virtual LoggerPtr getLogger() const;
     virtual Ice::Instrumentation::CommunicatorObserverPtr getObserver() const;
 
-    virtual RouterPrx getDefaultRouter() const;
-    virtual void setDefaultRouter(const RouterPrx&);
+    virtual RouterPrxPtr getDefaultRouter() const;
+    virtual void setDefaultRouter(const RouterPrxPtr&);
 
-    virtual LocatorPrx getDefaultLocator() const;
-    virtual void setDefaultLocator(const LocatorPrx&);
+    virtual LocatorPrxPtr getDefaultLocator() const;
+    virtual void setDefaultLocator(const LocatorPrxPtr&);
 
     virtual PluginManagerPtr getPluginManager() const;
 
-    virtual void flushBatchRequests();
-
-    virtual AsyncResultPtr begin_flushBatchRequests();
-    virtual AsyncResultPtr begin_flushBatchRequests(const CallbackPtr&, const LocalObjectPtr& = 0);
-    virtual AsyncResultPtr begin_flushBatchRequests(const Callback_Communicator_flushBatchRequestsPtr&,
+    virtual ValueFactoryManagerPtr getValueFactoryManager() const;
+
+#ifdef ICE_CPP11_MAPPING
+    virtual ::std::function<void()>
+    flushBatchRequestsAsync(CompressBatch,
+                            ::std::function<void(::std::exception_ptr)>,
+                            ::std::function<void(bool)> = nullptr);
+#else
+    virtual void flushBatchRequests(CompressBatch);
+    virtual AsyncResultPtr begin_flushBatchRequests(CompressBatch);
+    virtual AsyncResultPtr begin_flushBatchRequests(CompressBatch, const CallbackPtr&, const LocalObjectPtr& = 0);
+    virtual AsyncResultPtr begin_flushBatchRequests(CompressBatch,
+                                                    const Callback_Communicator_flushBatchRequestsPtr&,
                                                     const LocalObjectPtr& = 0);
 
-    virtual AsyncResultPtr begin_flushBatchRequests(
-        const IceInternal::Function<void (const Exception&)>&,
-        const IceInternal::Function<void (bool)>& = IceInternal::Function<void (bool)>());
-
     virtual void end_flushBatchRequests(const AsyncResultPtr&);
+#endif
 
-    virtual ObjectPrx createAdmin(const ObjectAdapterPtr&, const Identity&);
-    virtual ObjectPrx getAdmin() const;
+    virtual ObjectPrxPtr createAdmin(const ObjectAdapterPtr&, const Identity&);
+    virtual ObjectPrxPtr getAdmin() const;
     virtual void addAdminFacet(const ObjectPtr&, const std::string&);
     virtual ObjectPtr removeAdminFacet(const std::string&);
     virtual ObjectPtr findAdminFacet(const std::string&);
     virtual FacetMap findAllAdminFacets();
 
+    virtual ~CommunicatorI();
+
 private:
 
-    CommunicatorI(const InitializationData&);
-    virtual ~CommunicatorI();
+#ifndef ICE_CPP11_MAPPING
+    CommunicatorI() {}
+#endif
+
+    static CommunicatorIPtr create(const InitializationData&);
 
     //
     // Certain initialization tasks need to be completed after the
     // constructor.
     //
-    void finishSetup(int&, char*[]);
+    void finishSetup(int&, const char*[]);
 
-    friend ICE_API CommunicatorPtr initialize(int&, char*[], const InitializationData&, Int);
+    friend ICE_API CommunicatorPtr initialize(int&, const char*[], const InitializationData&, Int);
     friend ICE_API CommunicatorPtr initialize(StringSeq&, const InitializationData&, Int);
     friend ICE_API CommunicatorPtr initialize(const InitializationData&, Int);
     friend ICE_API ::IceInternal::InstancePtr IceInternal::getInstance(const ::Ice::CommunicatorPtr&);
     friend ICE_API ::IceUtil::TimerPtr IceInternal::getInstanceTimer(const ::Ice::CommunicatorPtr&);
 
-    AsyncResultPtr __begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&);
+#ifndef ICE_CPP11_MAPPING
+    AsyncResultPtr _iceI_begin_flushBatchRequests(CompressBatch,
+                                                  const IceInternal::CallbackBasePtr&,
+                                                  const LocalObjectPtr&);
+#endif
 
     const ::IceInternal::InstancePtr _instance;
 

data/ext/ice/cpp/src/{IceUtil → Ice}/Cond.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.
@@ -71,7 +71,7 @@ IceUtilInternal::Semaphore::timedWait(const IceUtil::Time& timeout) const
     if(msTimeout < 0 || msTimeout > 0x7FFFFFFF)
     {
         throw IceUtil::InvalidTimeoutException(__FILE__, __LINE__, timeout);
-    } 
+    }
 
     DWORD rc = WaitForSingleObject(_sem, static_cast<DWORD>(msTimeout));
     if(rc != WAIT_TIMEOUT && rc != WAIT_OBJECT_0)
@@ -333,7 +333,7 @@ IceUtil::Cond::Cond()
     }
 
 #if !defined(__hppa) && !defined(__APPLE__)
-    rc = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC); 
+    rc = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
     if(rc != 0)
     {
         throw ThreadSyscallException(__FILE__, __LINE__, rc);

data/ext/ice/cpp/src/Ice/ConnectRequestHandler.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.
@@ -14,7 +14,6 @@
 #include <Ice/Proxy.h>
 #include <Ice/ConnectionI.h>
 #include <Ice/RouterInfo.h>
-#include <Ice/Outgoing.h>
 #include <Ice/OutgoingAsync.h>
 #include <Ice/Protocol.h>
 #include <Ice/Properties.h>
@@ -23,9 +22,11 @@
 using namespace std;
 using namespace IceInternal;
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(ConnectRequestHandler* p) { return p; }
+#endif
 
-ConnectRequestHandler::ConnectRequestHandler(const ReferencePtr& ref, const Ice::ObjectPrx& proxy) :
+ConnectRequestHandler::ConnectRequestHandler(const ReferencePtr& ref, const Ice::ObjectPrxPtr& proxy) :
     RequestHandler(ref),
     _proxy(proxy),
     _initialized(false),
@@ -33,41 +34,21 @@ ConnectRequestHandler::ConnectRequestHandler(const ReferencePtr& ref, const Ice:
 {
 }
 
-ConnectRequestHandler::~ConnectRequestHandler()
-{
-}
-
 RequestHandlerPtr
-ConnectRequestHandler::connect(const Ice::ObjectPrx& proxy)
+ConnectRequestHandler::connect(const Ice::ObjectPrxPtr& proxy)
 {
     Lock sync(*this);
     if(!initialized())
     {
         _proxies.insert(proxy);
     }
-    return _requestHandler ? _requestHandler : this;
+    return _requestHandler ? _requestHandler : ICE_SHARED_FROM_THIS;
 }
 
 RequestHandlerPtr
 ConnectRequestHandler::update(const RequestHandlerPtr& previousHandler, const RequestHandlerPtr& newHandler)
 {
-    return previousHandler.get() == this ? newHandler : this;
-}
-
-bool
-ConnectRequestHandler::sendRequest(ProxyOutgoingBase* out)
-{
-    {
-        Lock sync(*this);
-        if(!initialized())
-        {
-            Request req;
-            req.out = out;
-            _requests.push_back(req);
-            return false; // Not sent
-        }
-    }
-    return out->invokeRemote(_connection, _compress, _response) && !_response; // Finished if sent and no response.
+    return previousHandler.get() == this ? newHandler : ICE_SHARED_FROM_THIS;
 }
 
 AsyncStatus
@@ -77,67 +58,38 @@ ConnectRequestHandler::sendAsyncRequest(const ProxyOutgoingAsyncBasePtr& out)
         Lock sync(*this);
         if(!_initialized)
         {
-            out->cancelable(this); // This will throw if the request is canceled
+            out->cancelable(ICE_SHARED_FROM_THIS); // This will throw if the request is canceled
         }
 
         if(!initialized())
         {
-            Request req;
-            req.outAsync = out;
-            _requests.push_back(req);
+            _requests.push_back(out);
             return AsyncStatusQueued;
         }
     }
     return out->invokeRemote(_connection, _compress, _response);
 }
 
-void
-ConnectRequestHandler::requestCanceled(OutgoingBase* out, const Ice::LocalException& ex)
-{
-    {
-        Lock sync(*this);
-        if(_exception.get())
-        {
-            return; // The request has been notified of a failure already.
-        }
-
-        if(!initialized())
-        {
-            for(deque<Request>::iterator p = _requests.begin(); p != _requests.end(); ++p)
-            {
-                if(p->out == out)
-                {
-                    out->completed(ex);
-                    _requests.erase(p);
-                    return;
-                }
-            }
-            assert(false); // The request has to be queued if it timed out and we're not initialized yet.
-        }
-    }
-    _connection->requestCanceled(out, ex);
-}
-
 void
 ConnectRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, const Ice::LocalException& ex)
 {
     {
         Lock sync(*this);
-        if(_exception.get())
+        if(_exception)
         {
             return; // The request has been notified of a failure already.
         }
 
         if(!initialized())
         {
-            for(deque<Request>::iterator p = _requests.begin(); p != _requests.end(); ++p)
+            for(deque<ProxyOutgoingAsyncBasePtr>::iterator p = _requests.begin(); p != _requests.end(); ++p)
             {
-                if(p->outAsync.get() == outAsync.get())
+                if(p->get() == outAsync.get())
                 {
                     _requests.erase(p);
-                    if(outAsync->completed(ex))
+                    if(outAsync->exception(ex))
                     {
-                        outAsync->invokeCompletedAsync();
+                        outAsync->invokeExceptionAsync();
                     }
                     return;
                 }
@@ -151,40 +103,34 @@ Ice::ConnectionIPtr
 ConnectRequestHandler::getConnection()
 {
     Lock sync(*this);
-    //
-    // First check for the connection, it's important otherwise the user could first get a connection
-    // and then the exception if he tries to obtain the proxy cached connection mutiple times (the
-    // exception can be set after the connection is set if the flush of pending requests fails).
-    //
-    if(_connection)
+    if(_exception)
     {
-        return _connection;
+        _exception->ice_throw();
+        return 0; // Keep the compiler happy.
     }
-    else if(_exception.get())
+    else
     {
-        _exception->ice_throw();
+        return _connection;
     }
-    return 0;
 }
 
 Ice::ConnectionIPtr
 ConnectRequestHandler::waitForConnection()
 {
     Lock sync(*this);
-    if(_exception.get())
+    if(_exception)
     {
-        throw RetryException(*_exception.get());
+        throw RetryException(*_exception);
     }
-
     //
     // Wait for the connection establishment to complete or fail.
     //
-    while(!_initialized && !_exception.get())
+    while(!_initialized && !_exception)
     {
         wait();
     }
 
-    if(_exception.get())
+    if(_exception)
     {
         _exception->ice_throw();
         return 0; // Keep the compiler happy.
@@ -200,7 +146,7 @@ ConnectRequestHandler::setConnection(const Ice::ConnectionIPtr& connection, bool
 {
     {
         Lock sync(*this);
-        assert(!_flushing && !_exception.get() && !_connection);
+        assert(!_flushing && !_exception && !_connection);
         _connection = connection;
         _compress = compress;
     }
@@ -210,7 +156,7 @@ ConnectRequestHandler::setConnection(const Ice::ConnectionIPtr& connection, bool
     // add this proxy to the router info object.
     //
     RouterInfoPtr ri = _reference->getRouterInfo();
-    if(ri && !ri->addProxy(_proxy, this))
+    if(ri && !ri->addProxy(_proxy, ICE_SHARED_FROM_THIS))
     {
         return; // The request handler will be initialized once addProxy returns.
     }
@@ -226,9 +172,9 @@ ConnectRequestHandler::setException(const Ice::LocalException& ex)
 {
     {
         Lock sync(*this);
-        assert(!_flushing && !_initialized && !_exception.get());
+        assert(!_flushing && !_initialized && !_exception);
         _flushing = true; // Ensures request handler is removed before processing new requests.
-        _exception.reset(ex.ice_clone());
+        ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone());
     }
 
     //
@@ -238,25 +184,18 @@ ConnectRequestHandler::setException(const Ice::LocalException& ex)
     //
     try
     {
-        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
+        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
     }
     catch(const Ice::CommunicatorDestroyedException&)
     {
         // Ignore
     }
 
-    for(deque<Request>::const_iterator p = _requests.begin(); p != _requests.end(); ++p)
+    for(deque<ProxyOutgoingAsyncBasePtr>::const_iterator p = _requests.begin(); p != _requests.end(); ++p)
     {
-        if(p->out)
-        {
-            p->out->completed(*_exception.get());
-        }
-        else
+        if((*p)->exception(ex))
         {
-            if(p->outAsync->completed(*_exception.get()))
-            {
-                p->outAsync->invokeCompletedAsync();
-            }
+            (*p)->invokeExceptionAsync();
         }
     }
     _requests.clear();
@@ -297,7 +236,7 @@ ConnectRequestHandler::initialized()
             wait();
         }
 
-        if(_exception.get())
+        if(_exception)
         {
             if(_connection)
             {
@@ -334,47 +273,37 @@ ConnectRequestHandler::flushRequests()
         _flushing = true;
     }
 
-    IceUtil::UniquePtr<Ice::LocalException> exception;
+#ifdef ICE_CPP11_MAPPING
+    std::unique_ptr<Ice::LocalException> exception;
+#else
+    IceInternal::UniquePtr<Ice::LocalException> exception;
+#endif
     while(!_requests.empty()) // _requests is immutable when _flushing = true
     {
-        Request& req = _requests.front();
+        ProxyOutgoingAsyncBasePtr& req = _requests.front();
         try
         {
-            if(req.out)
+            if(req->invokeRemote(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
             {
-                req.out->invokeRemote(_connection, _compress, _response);
-            }
-            else if(req.outAsync->invokeRemote(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
-            {
-                req.outAsync->invokeSentAsync();
+                req->invokeSentAsync();
             }
         }
         catch(const RetryException& ex)
         {
-            exception.reset(ex.get()->ice_clone());
+            ICE_SET_EXCEPTION_FROM_CLONE(exception, ex.get()->ice_clone());
 
             // Remove the request handler before retrying.
-            _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
+            _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
 
-            if(req.out)
-            {
-                req.out->retryException(*ex.get());
-            }
-            else
-            {
-                req.outAsync->retryException(*ex.get());
-            }
+            req->retryException(*exception);
         }
         catch(const Ice::LocalException& ex)
         {
-            exception.reset(ex.ice_clone());
-            if(req.out)
-            {
-                req.out->completed(ex);
-            }
-            else if(req.outAsync->completed(ex))
+            ICE_SET_EXCEPTION_FROM_CLONE(exception, ex.ice_clone());
+
+            if(req->exception(ex))
             {
-                req.outAsync->invokeCompletedAsync();
+                req->invokeExceptionAsync();
             }
         }
         _requests.pop_front();
@@ -386,30 +315,34 @@ ConnectRequestHandler::flushRequests()
     // request handler to use the more efficient connection request
     // handler.
     //
-    if(_reference->getCacheConnection() && !exception.get())
+    if(_reference->getCacheConnection() && !exception)
     {
-        _requestHandler = new ConnectionRequestHandler(_reference, _connection, _compress);
-        for(set<Ice::ObjectPrx>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
+        _requestHandler = ICE_MAKE_SHARED(ConnectionRequestHandler, _reference, _connection, _compress);
+        for(set<Ice::ObjectPrxPtr>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
         {
-            (*p)->__updateRequestHandler(this, _requestHandler);
+            (*p)->_updateRequestHandler(ICE_SHARED_FROM_THIS, _requestHandler);
         }
     }
 
     {
         Lock sync(*this);
         assert(!_initialized);
+#ifdef ICE_CPP11_MAPPING
+        swap(_exception, exception);
+#else
         _exception.swap(exception);
-        _initialized = !_exception.get();
+#endif
+        _initialized = !_exception;
         _flushing = false;
 
         //
         // Only remove once all the requests are flushed to
         // guarantee serialization.
         //
-        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, this);
+        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
 
         _proxies.clear();
-        _proxy = 0; // Break cyclic reference count.
+        _proxy = ICE_NULLPTR; // Break cyclic reference count.
         notifyAll();
     }
 }