zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/RetryQueue.h

@@ -1,66 +1,59 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RETRY_QUEUE_H
 #define ICE_RETRY_QUEUE_H
 
-#include <IceUtil/Shared.h>
-#include <IceUtil/Mutex.h>
-#include <IceUtil/Timer.h>
-#include <Ice/RetryQueueF.h>
-#include <Ice/OutgoingAsyncF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/RequestHandler.h> // For CancellationHandler
+#include "Ice/InstanceF.h"
+#include "RequestHandler.h" // For CancellationHandler
+#include "RetryQueueF.h"
+#include "Timer.h"
 
-namespace IceInternal
-{
+#include <mutex>
 
-class RetryTask : public IceUtil::TimerTask,
-                  public CancellationHandler
-#ifdef ICE_CPP11_MAPPING
-                , public std::enable_shared_from_this<RetryTask>
-#endif
+namespace IceInternal
 {
-public:
-
-    RetryTask(const InstancePtr&, const RetryQueuePtr&, const ProxyOutgoingAsyncBasePtr&);
+    class OutgoingAsyncBase;
+    class ProxyOutgoingAsyncBase;
 
-    virtual void runTimerTask();
+    using OutgoingAsyncBasePtr = std::shared_ptr<OutgoingAsyncBase>;
+    using ProxyOutgoingAsyncBasePtr = std::shared_ptr<ProxyOutgoingAsyncBase>;
 
-    virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&);
+    class RetryTask : public TimerTask, public CancellationHandler, public std::enable_shared_from_this<RetryTask>
+    {
+    public:
+        RetryTask(InstancePtr, RetryQueuePtr, ProxyOutgoingAsyncBasePtr);
 
-    void destroy();
+        void runTimerTask() override;
 
-    bool operator<(const RetryTask&) const;
-
-private:
-
-    const InstancePtr _instance;
-    const RetryQueuePtr _queue;
-    const ProxyOutgoingAsyncBasePtr _outAsync;
-};
-ICE_DEFINE_PTR(RetryTaskPtr, RetryTask);
-
-class RetryQueue : public IceUtil::Shared, public IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
+        void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) override;
 
-    RetryQueue(const InstancePtr&);
+        void destroy();
 
-    void add(const ProxyOutgoingAsyncBasePtr&, int);
-    void destroy();
+    private:
+        const InstancePtr _instance;
+        const RetryQueuePtr _queue;
+        const ProxyOutgoingAsyncBasePtr _outAsync;
+    };
+    using RetryTaskPtr = std::shared_ptr<RetryTask>;
 
-private:
+    class RetryQueue : public std::enable_shared_from_this<RetryQueue>
+    {
+    public:
+        RetryQueue(InstancePtr);
 
-    void remove(const RetryTaskPtr&);
-    bool cancel(const RetryTaskPtr&);
-    friend class RetryTask;
+        void add(const ProxyOutgoingAsyncBasePtr&, int);
+        void destroy();
 
-    InstancePtr _instance;
-    std::set<RetryTaskPtr> _requests;
-};
+    private:
+        void remove(const RetryTaskPtr&);
+        bool cancel(const RetryTaskPtr&);
+        friend class RetryTask;
 
+        InstancePtr _instance;
+        std::set<RetryTaskPtr> _requests;
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
 }
 
 #endif

data/dist/ice/cpp/src/Ice/RetryQueueF.h

@@ -1,19 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RETRY_QUEUE_F_H
 #define ICE_RETRY_QUEUE_F_H
 
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
-
-class RetryQueue;
-IceUtil::Shared* upCast(RetryQueue*);
-typedef Handle<RetryQueue> RetryQueuePtr;
-
+    class RetryQueue;
+    using RetryQueuePtr = std::shared_ptr<RetryQueue>;
 }
 
 #endif

data/dist/ice/cpp/src/Ice/RouterInfo.cpp

@@ -1,73 +1,57 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/RouterInfo.h>
-#include <Ice/Router.h>
-#include <Ice/LocalException.h>
-#include <Ice/Connection.h> // For ice_connection()->timeout().
-#include <Ice/Functional.h>
-#include <Ice/Reference.h>
+#include "RouterInfo.h"
+#include "Ice/Connection.h" // For ice_connection()->timeout().
+#include "Ice/LocalExceptions.h"
+#include "Ice/ProxyFunctions.h"
+#include "Ice/Router.h"
+#include "Reference.h"
+
+#include <cassert>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(RouterManager* p) { return p; }
-IceUtil::Shared* IceInternal::upCast(RouterInfo* p) { return p; }
-
-IceInternal::RouterManager::RouterManager() :
-    _tableHint(_table.end())
-{
-}
+IceInternal::RouterManager::RouterManager() : _tableHint(_table.end()) {}
 
 void
 IceInternal::RouterManager::destroy()
 {
-    IceUtil::Mutex::Lock sync(*this);
-#ifdef ICE_CPP11_COMPILER
-    for_each(_table.begin(), _table.end(),
-             [](const pair<RouterPrxPtr, RouterInfoPtr> it)
-             {
-                 it.second->destroy();
-             });
-#else
-    for_each(_table.begin(), _table.end(), Ice::secondVoidMemFun<const RouterPrx, RouterInfo>(&RouterInfo::destroy));
-#endif
+    lock_guard lock(_mutex);
+    for (const auto& [_, routerInfo] : _table)
+    {
+        routerInfo->destroy();
+    }
     _table.clear();
     _tableHint = _table.end();
 }
 
 RouterInfoPtr
-IceInternal::RouterManager::get(const RouterPrxPtr& rtr)
+IceInternal::RouterManager::get(const RouterPrx& rtr)
 {
-    if(!rtr)
-    {
-        return 0;
-    }
+    RouterPrx router = rtr->ice_router(nullopt); // The router cannot be routed.
 
-    RouterPrxPtr router = rtr->ice_router(0); // The router cannot be routed.
+    lock_guard lock(_mutex);
 
-    IceUtil::Mutex::Lock sync(*this);
+    auto p = _table.end();
 
-    RouterInfoTable::iterator p = _table.end();
-
-    if(_tableHint != _table.end())
+    if (_tableHint != _table.end())
     {
-        if(targetEqualTo(_tableHint->first, router))
+        if (_tableHint->first == router)
         {
             p = _tableHint;
         }
     }
 
-    if(p == _table.end())
+    if (p == _table.end())
     {
         p = _table.find(router);
     }
 
-    if(p == _table.end())
+    if (p == _table.end())
     {
-        _tableHint = _table.insert(_tableHint, pair<const RouterPrxPtr, RouterInfoPtr>(router, new RouterInfo(router)));
+        _tableHint = _table.insert(_tableHint, pair<const RouterPrx, RouterInfoPtr>(router, new RouterInfo(router)));
     }
     else
     {
@@ -77,172 +61,123 @@ IceInternal::RouterManager::get(const RouterPrxPtr& rtr)
     return _tableHint->second;
 }
 
-RouterInfoPtr
-IceInternal::RouterManager::erase(const RouterPrxPtr& rtr)
+void
+IceInternal::RouterManager::erase(const RouterPrx& router)
 {
-    RouterInfoPtr info;
-    if(rtr)
-    {
-        RouterPrxPtr router = ICE_UNCHECKED_CAST(RouterPrx, rtr->ice_router(ICE_NULLPTR)); // The router cannot be routed.
-        IceUtil::Mutex::Lock sync(*this);
+    assert(!router->ice_getRouter()); // The router cannot be routed.
 
-        RouterInfoTable::iterator p = _table.end();
-        if(_tableHint != _table.end() && targetEqualTo(_tableHint->first, router))
-        {
-            p = _tableHint;
-            _tableHint = _table.end();
-        }
+    lock_guard lock(_mutex);
 
-        if(p == _table.end())
-        {
-            p = _table.find(router);
-        }
+    auto p = _table.end();
+    if (_tableHint != _table.end() && _tableHint->first == router)
+    {
+        p = _tableHint;
+        _tableHint = _table.end();
+    }
 
-        if(p != _table.end())
-        {
-            info = p->second;
-            _table.erase(p);
-        }
+    if (p == _table.end())
+    {
+        p = _table.find(router);
     }
 
-    return info;
+    if (p != _table.end())
+    {
+        _table.erase(p);
+    }
 }
 
-IceInternal::RouterInfo::RouterInfo(const RouterPrxPtr& router) : _router(router), _hasRoutingTable(false)
-{
-    assert(_router);
-}
+IceInternal::RouterInfo::RouterInfo(RouterPrx router) : _router(std::move(router)) {}
 
 void
 IceInternal::RouterInfo::destroy()
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     _clientEndpoints.clear();
-    _adapter = 0;
+    _adapter = nullptr;
     _identities.clear();
 }
 
 bool
 IceInternal::RouterInfo::operator==(const RouterInfo& rhs) const
 {
-    return Ice::targetEqualTo(_router, rhs._router);
+    return _router == rhs._router;
 }
 
 bool
 IceInternal::RouterInfo::operator<(const RouterInfo& rhs) const
 {
-    return Ice::targetLess(_router, rhs._router);
+    return _router < rhs._router;
 }
 
 vector<EndpointIPtr>
 IceInternal::RouterInfo::getClientEndpoints()
 {
     {
-        IceUtil::Mutex::Lock sync(*this);
-        if(!_clientEndpoints.empty())
+        lock_guard lock(_mutex);
+        if (!_clientEndpoints.empty())
         {
             return _clientEndpoints;
         }
     }
 
-    IceUtil::Optional<bool> hasRoutingTable;
-    Ice::ObjectPrxPtr proxy = _router->getClientProxy(hasRoutingTable);
+    optional<bool> hasRoutingTable;
+    optional<ObjectPrx> proxy = _router->getClientProxy(hasRoutingTable);
     return setClientEndpoints(proxy, hasRoutingTable ? hasRoutingTable.value() : true);
 }
 
 void
-IceInternal::RouterInfo::getClientProxyResponse(const Ice::ObjectPrxPtr& proxy,
-                                                const IceUtil::Optional<bool>& hasRoutingTable,
-                                                const GetClientEndpointsCallbackPtr& callback)
-{
-    callback->setEndpoints(setClientEndpoints(proxy, hasRoutingTable ? hasRoutingTable.value() : true));
-}
-
-void
-IceInternal::RouterInfo::getClientProxyException(const Ice::Exception& ex,
-                                                 const GetClientEndpointsCallbackPtr& callback)
-{
-    callback->setException(dynamic_cast<const Ice::LocalException&>(ex));
-}
-
-void
-IceInternal::RouterInfo::getClientEndpoints(const GetClientEndpointsCallbackPtr& callback)
+IceInternal::RouterInfo::getClientEndpointsAsync(
+    std::function<void(vector<EndpointIPtr>)> response,
+    std::function<void(std::exception_ptr)> ex)
 {
     vector<EndpointIPtr> clientEndpoints;
     {
-        IceUtil::Mutex::Lock sync(*this);
+        lock_guard lock(_mutex);
         clientEndpoints = _clientEndpoints;
     }
 
-    if(!clientEndpoints.empty())
+    if (!clientEndpoints.empty())
     {
-        callback->setEndpoints(clientEndpoints);
+        response(std::move(clientEndpoints));
         return;
     }
 
-#ifdef ICE_CPP11_MAPPING
-    RouterInfoPtr self = this;
+    RouterInfoPtr self = shared_from_this();
     _router->getClientProxyAsync(
-        [self, callback](const Ice::ObjectPrxPtr& proxy, Ice::optional<bool> hasRoutingTable)
-        {
-            self->getClientProxyResponse(proxy, hasRoutingTable, callback);
-        },
-        [self, callback](exception_ptr e)
-        {
-            try
-            {
-                rethrow_exception(e);
-            }
-            catch(const Ice::Exception& ex)
-            {
-                self->getClientProxyException(ex, callback);
-            }
-        });
-#else
-    _router->begin_getClientProxy(newCallback_Router_getClientProxy(this,
-                                                                    &RouterInfo::getClientProxyResponse,
-                                                                    &RouterInfo::getClientProxyException),
-                                  callback);
-#endif
+        [self, response = std::move(response)](const optional<Ice::ObjectPrx>& proxy, optional<bool> hasRoutingTable)
+        { response(self->setClientEndpoints(proxy, hasRoutingTable.value_or(true))); },
+        std::move(ex));
 }
 
 vector<EndpointIPtr>
 IceInternal::RouterInfo::getServerEndpoints()
 {
-    Ice::ObjectPrxPtr serverProxy = _router->getServerProxy();
-    if(!serverProxy)
+    optional<ObjectPrx> serverProxy = _router->getServerProxy();
+    if (!serverProxy)
     {
-        throw NoEndpointException(__FILE__, __LINE__);
+        throw NoEndpointException{__FILE__, __LINE__, "Router::getServerProxy returned a null proxy"};
     }
-    serverProxy = serverProxy->ice_router(0); // The server proxy cannot be routed.
+    serverProxy = serverProxy->ice_router(nullopt); // The server proxy cannot be routed.
     return serverProxy->_getReference()->getEndpoints();
 }
 
-void
-IceInternal::RouterInfo::addProxyResponse(const Ice::ObjectProxySeq& proxies, const AddProxyCookiePtr& cookie)
-{
-    addAndEvictProxies(cookie->proxy(), proxies);
-    cookie->cb()->addedProxy();
-}
-
-void
-IceInternal::RouterInfo::addProxyException(const Ice::Exception& ex, const AddProxyCookiePtr& cookie)
-{
-    cookie->cb()->setException(dynamic_cast<const Ice::LocalException&>(ex));
-}
-
 bool
-IceInternal::RouterInfo::addProxy(const Ice::ObjectPrxPtr& proxy, const AddProxyCallbackPtr& callback)
+IceInternal::RouterInfo::addProxyAsync(
+    const ReferencePtr& reference,
+    function<void()> response,
+    function<void(exception_ptr)> ex)
 {
-    assert(proxy);
+    assert(reference);
+    Identity identity = reference->getIdentity();
+
     {
-        IceUtil::Mutex::Lock sync(*this);
-        if(!_hasRoutingTable)
+        lock_guard lock(_mutex);
+        if (!_hasRoutingTable)
         {
             return true; // The router implementation doesn't maintain a routing table.
         }
-        else if(_identities.find(proxy->ice_getIdentity()) != _identities.end())
+        else if (_identities.find(identity) != _identities.end())
         {
             //
             // Only add the proxy to the router if it's not already in our local map.
@@ -252,103 +187,64 @@ IceInternal::RouterInfo::addProxy(const Ice::ObjectPrxPtr& proxy, const AddProxy
     }
 
     Ice::ObjectProxySeq proxies;
-    proxies.push_back(proxy);
-    AddProxyCookiePtr cookie = new AddProxyCookie(callback, proxy);
+    proxies.emplace_back(ObjectPrx::_fromReference(reference));
 
-#ifdef ICE_CPP11_MAPPING
-    RouterInfoPtr self = this;
-    _router->addProxiesAsync(proxies,
-        [self, cookie](const Ice::ObjectProxySeq& p)
+    _router->addProxiesAsync(
+        proxies,
+        [response = std::move(response), self = shared_from_this(), identity = std::move(identity)](
+            const Ice::ObjectProxySeq& evictedProxies)
         {
-            self->addProxyResponse(p, cookie);
+            self->addAndEvictProxies(identity, evictedProxies);
+            response();
         },
-        [self, cookie](exception_ptr e)
-        {
-            try
-            {
-                rethrow_exception(e);
-            }
-            catch(const Ice::Exception& ex)
-            {
-                self->addProxyException(ex, cookie);
-            }
-        });
-#else
-    _router->begin_addProxies(proxies,
-                              newCallback_Router_addProxies(this,
-                                                            &RouterInfo::addProxyResponse,
-                                                            &RouterInfo::addProxyException),
-                              cookie);
-#endif
+        std::move(ex));
     return false;
 }
 
 void
 IceInternal::RouterInfo::setAdapter(const ObjectAdapterPtr& adapter)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
     _adapter = adapter;
 }
 
 ObjectAdapterPtr
 IceInternal::RouterInfo::getAdapter() const
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
     return _adapter;
 }
 
 void
 IceInternal::RouterInfo::clearCache(const ReferencePtr& ref)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
     _identities.erase(ref->getIdentity());
 }
 
 vector<EndpointIPtr>
-IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrxPtr& proxy, bool hasRoutingTable)
+IceInternal::RouterInfo::setClientEndpoints(const optional<ObjectPrx>& proxy, bool hasRoutingTable)
 {
-    IceUtil::Mutex::Lock sync(*this);
-    if(_clientEndpoints.empty())
+    lock_guard lock(_mutex);
+    if (_clientEndpoints.empty())
     {
         _hasRoutingTable = hasRoutingTable;
-        if(!proxy)
-        {
-            //
-            // If getClientProxy() return nil, use router endpoints.
-            //
-            _clientEndpoints = _router->_getReference()->getEndpoints();
-        }
-        else
-        {
-            Ice::ObjectPrxPtr clientProxy = proxy->ice_router(0); // The client proxy cannot be routed.
-
-            //
-            // In order to avoid creating a new connection to the router,
-            // we must use the same timeout as the already existing
-            // connection.
-            //
-            if(_router->ice_getConnection())
-            {
-                clientProxy = clientProxy->ice_timeout(_router->ice_getConnection()->timeout());
-            }
-
-            _clientEndpoints = clientProxy->_getReference()->getEndpoints();
-        }
+        _clientEndpoints = proxy ? proxy->_getReference()->getEndpoints() : _router->_getReference()->getEndpoints();
     }
     return _clientEndpoints;
 }
 
 void
-IceInternal::RouterInfo::addAndEvictProxies(const Ice::ObjectPrxPtr& proxy, const Ice::ObjectProxySeq& evictedProxies)
+IceInternal::RouterInfo::addAndEvictProxies(const Identity& identity, const Ice::ObjectProxySeq& evictedProxies)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     //
     // Check if the proxy hasn't already been evicted by a concurrent addProxies call.
     // If it's the case, don't add it to our local map.
     //
-    multiset<Identity>::iterator p = _evictedIdentities.find(proxy->ice_getIdentity());
-    if(p != _evictedIdentities.end())
+    auto p = _evictedIdentities.find(identity);
+    if (p != _evictedIdentities.end())
     {
         _evictedIdentities.erase(p);
     }
@@ -358,22 +254,22 @@ IceInternal::RouterInfo::addAndEvictProxies(const Ice::ObjectPrxPtr& proxy, cons
         // If we successfully added the proxy to the router,
         // we add it to our local map.
         //
-        _identities.insert(proxy->ice_getIdentity());
+        _identities.insert(identity);
     }
 
     //
     // We also must remove whatever proxies the router evicted.
     //
-    for(Ice::ObjectProxySeq::const_iterator q = evictedProxies.begin(); q != evictedProxies.end(); ++q)
+    for (const auto& evictedProxy : evictedProxies)
     {
-        if(_identities.erase((*q)->ice_getIdentity()) == 0)
+        if (_identities.erase(evictedProxy->ice_getIdentity()) == 0)
         {
             //
             // It's possible for the proxy to not have been
             // added yet in the local map if two threads
             // concurrently call addProxies.
             //
-            _evictedIdentities.insert((*q)->ice_getIdentity());
+            _evictedIdentities.insert(evictedProxy->ice_getIdentity());
         }
     }
 }