zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Ice/RouterF.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,23 +23,46 @@
 #endif
 #include <Ice/RouterF.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.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/RouterInfo.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.
@@ -30,35 +30,37 @@ void
 IceInternal::RouterManager::destroy()
 {
     IceUtil::Mutex::Lock sync(*this);
-
+#ifdef ICE_CPP11_MAPPING
+    for_each(_table.begin(), _table.end(), [](const pair<shared_ptr<RouterPrx>, RouterInfoPtr> it){ it.second->destroy(); });
+#else
     for_each(_table.begin(), _table.end(), Ice::secondVoidMemFun<const RouterPrx, RouterInfo>(&RouterInfo::destroy));
-
+#endif
     _table.clear();
     _tableHint = _table.end();
 }
 
 RouterInfoPtr
-IceInternal::RouterManager::get(const RouterPrx& rtr)
+IceInternal::RouterManager::get(const RouterPrxPtr& rtr)
 {
     if(!rtr)
     {
         return 0;
     }
 
-    RouterPrx router = RouterPrx::uncheckedCast(rtr->ice_router(0)); // The router cannot be routed.
+    RouterPrxPtr router = rtr->ice_router(0); // The router cannot be routed.
 
     IceUtil::Mutex::Lock sync(*this);
 
-    map<RouterPrx, RouterInfoPtr>::iterator p = _table.end();
-    
+    RouterInfoTable::iterator p = _table.end();
+
     if(_tableHint != _table.end())
     {
-        if(_tableHint->first == router)
+        if(targetEqualTo(_tableHint->first, router))
         {
             p = _tableHint;
         }
     }
-    
+
     if(p == _table.end())
     {
         p = _table.find(router);
@@ -66,7 +68,7 @@ IceInternal::RouterManager::get(const RouterPrx& rtr)
 
     if(p == _table.end())
     {
-        _tableHint = _table.insert(_tableHint, pair<const RouterPrx, RouterInfoPtr>(router, new RouterInfo(router)));
+        _tableHint = _table.insert(_tableHint, pair<const RouterPrxPtr, RouterInfoPtr>(router, new RouterInfo(router)));
     }
     else
     {
@@ -77,26 +79,26 @@ IceInternal::RouterManager::get(const RouterPrx& rtr)
 }
 
 RouterInfoPtr
-IceInternal::RouterManager::erase(const RouterPrx& rtr)
+IceInternal::RouterManager::erase(const RouterPrxPtr& rtr)
 {
     RouterInfoPtr info;
     if(rtr)
     {
-        RouterPrx router = RouterPrx::uncheckedCast(rtr->ice_router(0)); // The router cannot be routed.
+        RouterPrxPtr router = ICE_UNCHECKED_CAST(RouterPrx, rtr->ice_router(ICE_NULLPTR)); // The router cannot be routed.
         IceUtil::Mutex::Lock sync(*this);
 
-        map<RouterPrx, RouterInfoPtr>::iterator p = _table.end();
-        if(_tableHint != _table.end() && _tableHint->first == router)
+        RouterInfoTable::iterator p = _table.end();
+        if(_tableHint != _table.end() && targetEqualTo(_tableHint->first, router))
         {
             p = _tableHint;
             _tableHint = _table.end();
         }
-        
+
         if(p == _table.end())
         {
             p = _table.find(router);
         }
-        
+
         if(p != _table.end())
         {
             info = p->second;
@@ -107,8 +109,7 @@ IceInternal::RouterManager::erase(const RouterPrx& rtr)
     return info;
 }
 
-IceInternal::RouterInfo::RouterInfo(const RouterPrx& router) :
-    _router(router)
+IceInternal::RouterInfo::RouterInfo(const RouterPrxPtr& router) : _router(router), _hasRoutingTable(false)
 {
     assert(_router);
 }
@@ -127,19 +128,13 @@ IceInternal::RouterInfo::destroy()
 bool
 IceInternal::RouterInfo::operator==(const RouterInfo& rhs) const
 {
-    return _router == rhs._router;
-}
-
-bool
-IceInternal::RouterInfo::operator!=(const RouterInfo& rhs) const
-{
-    return _router != rhs._router;
+    return Ice::targetEqualTo(_router, rhs._router);
 }
 
 bool
 IceInternal::RouterInfo::operator<(const RouterInfo& rhs) const
 {
-    return _router < rhs._router;
+    return Ice::targetLess(_router, rhs._router);
 }
 
 vector<EndpointIPtr>
@@ -153,18 +148,21 @@ IceInternal::RouterInfo::getClientEndpoints()
         }
     }
 
-    return setClientEndpoints(_router->getClientProxy());
+    IceUtil::Optional<bool> hasRoutingTable;
+    Ice::ObjectPrxPtr proxy = _router->getClientProxy(hasRoutingTable);
+    return setClientEndpoints(proxy, hasRoutingTable ? hasRoutingTable.value() : true);
 }
 
 void
-IceInternal::RouterInfo::getClientProxyResponse(const Ice::ObjectPrx& proxy, 
+IceInternal::RouterInfo::getClientProxyResponse(const Ice::ObjectPrxPtr& proxy,
+                                                const IceUtil::Optional<bool>& hasRoutingTable,
                                                 const GetClientEndpointsCallbackPtr& callback)
 {
-    callback->setEndpoints(setClientEndpoints(proxy));
+    callback->setEndpoints(setClientEndpoints(proxy, hasRoutingTable ? hasRoutingTable.value() : true));
 }
 
 void
-IceInternal::RouterInfo::getClientProxyException(const Ice::Exception& ex, 
+IceInternal::RouterInfo::getClientProxyException(const Ice::Exception& ex,
                                                  const GetClientEndpointsCallbackPtr& callback)
 {
     callback->setException(dynamic_cast<const Ice::LocalException&>(ex));
@@ -185,10 +183,30 @@ IceInternal::RouterInfo::getClientEndpoints(const GetClientEndpointsCallbackPtr&
         return;
     }
 
-    _router->begin_getClientProxy(newCallback_Router_getClientProxy(this, 
-                                                                    &RouterInfo::getClientProxyResponse, 
+#ifdef ICE_CPP11_MAPPING
+    RouterInfoPtr self = 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
 }
 
 vector<EndpointIPtr>
@@ -205,27 +223,6 @@ IceInternal::RouterInfo::getServerEndpoints()
     return setServerEndpoints(_router->getServerProxy());
 }
 
-void
-IceInternal::RouterInfo::addProxy(const ObjectPrx& proxy)
-{
-    assert(proxy); // Must not be called for null proxies.
-
-    {
-        IceUtil::Mutex::Lock sync(*this);
-        if(_identities.find(proxy->ice_getIdentity()) != _identities.end())
-        {
-            //
-            // Only add the proxy to the router if it's not already in our local map.
-            //
-            return;
-        }
-    }
-
-    ObjectProxySeq proxies;
-    proxies.push_back(proxy);
-    addAndEvictProxies(proxy, _router->addProxies(proxies));
-}
-
 void
 IceInternal::RouterInfo::addProxyResponse(const Ice::ObjectProxySeq& proxies, const AddProxyCookiePtr& cookie)
 {
@@ -240,12 +237,16 @@ IceInternal::RouterInfo::addProxyException(const Ice::Exception& ex, const AddPr
 }
 
 bool
-IceInternal::RouterInfo::addProxy(const Ice::ObjectPrx& proxy, const AddProxyCallbackPtr& callback)
+IceInternal::RouterInfo::addProxy(const Ice::ObjectPrxPtr& proxy, const AddProxyCallbackPtr& callback)
 {
     assert(proxy);
     {
         IceUtil::Mutex::Lock sync(*this);
-        if(_identities.find(proxy->ice_getIdentity()) != _identities.end())
+        if(!_hasRoutingTable)
+        {
+            return true; // The router implementation doesn't maintain a routing table.
+        }
+        else if(_identities.find(proxy->ice_getIdentity()) != _identities.end())
         {
             //
             // Only add the proxy to the router if it's not already in our local map.
@@ -254,15 +255,35 @@ IceInternal::RouterInfo::addProxy(const Ice::ObjectPrx& proxy, const AddProxyCal
         }
     }
 
-
     Ice::ObjectProxySeq proxies;
     proxies.push_back(proxy);
     AddProxyCookiePtr cookie = new AddProxyCookie(callback, proxy);
+
+#ifdef ICE_CPP11_MAPPING
+    RouterInfoPtr self = this;
+    _router->addProxiesAsync(proxies,
+        [self, cookie](const Ice::ObjectProxySeq& proxies)
+        {
+            self->addProxyResponse(proxies, cookie);
+        },
+        [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), 
+                              newCallback_Router_addProxies(this,
+                                                            &RouterInfo::addProxyResponse,
+                                                            &RouterInfo::addProxyException),
                               cookie);
+#endif
     return false;
 }
 
@@ -288,21 +309,22 @@ IceInternal::RouterInfo::clearCache(const ReferencePtr& ref)
 }
 
 vector<EndpointIPtr>
-IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrx& proxy)
+IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrxPtr& proxy, bool hasRoutingTable)
 {
     IceUtil::Mutex::Lock sync(*this);
     if(_clientEndpoints.empty())
     {
+        _hasRoutingTable = hasRoutingTable;
         if(!proxy)
         {
             //
             // If getClientProxy() return nil, use router endpoints.
             //
-            _clientEndpoints = _router->__reference()->getEndpoints();
+            _clientEndpoints = _router->_getReference()->getEndpoints();
         }
         else
         {
-            Ice::ObjectPrx clientProxy = proxy->ice_router(0); // The client proxy cannot be routed.
+            Ice::ObjectPrxPtr clientProxy = proxy->ice_router(0); // The client proxy cannot be routed.
 
             //
             // In order to avoid creating a new connection to the router,
@@ -314,20 +336,19 @@ IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrx& proxy)
                 clientProxy = clientProxy->ice_timeout(_router->ice_getConnection()->timeout());
             }
 
-            _clientEndpoints = clientProxy->__reference()->getEndpoints();
+            _clientEndpoints = clientProxy->_getReference()->getEndpoints();
         }
     }
     return _clientEndpoints;
 }
 
-
 vector<EndpointIPtr>
-IceInternal::RouterInfo::setServerEndpoints(const Ice::ObjectPrx& /*serverProxy*/)
+IceInternal::RouterInfo::setServerEndpoints(const Ice::ObjectPrxPtr& /*serverProxy*/)
 {
     IceUtil::Mutex::Lock sync(*this);
     if(_serverEndpoints.empty()) // Lazy initialization.
     {
-        ObjectPrx serverProxy = _router->getServerProxy();
+        ObjectPrxPtr serverProxy = _router->getServerProxy();
         if(!serverProxy)
         {
             throw NoEndpointException(__FILE__, __LINE__);
@@ -335,18 +356,18 @@ IceInternal::RouterInfo::setServerEndpoints(const Ice::ObjectPrx& /*serverProxy*
 
         serverProxy = serverProxy->ice_router(0); // The server proxy cannot be routed.
 
-        _serverEndpoints = serverProxy->__reference()->getEndpoints();
+        _serverEndpoints = serverProxy->_getReference()->getEndpoints();
     }
     return _serverEndpoints;
 }
 
 void
-IceInternal::RouterInfo::addAndEvictProxies(const Ice::ObjectPrx& proxy, const Ice::ObjectProxySeq& evictedProxies)
+IceInternal::RouterInfo::addAndEvictProxies(const Ice::ObjectPrxPtr& proxy, const Ice::ObjectProxySeq& evictedProxies)
 {
     IceUtil::Mutex::Lock sync(*this);
 
     //
-    // Check if the proxy hasn't already been evicted by a concurrent addProxies call. 
+    // 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());
@@ -362,7 +383,7 @@ IceInternal::RouterInfo::addAndEvictProxies(const Ice::ObjectPrx& proxy, const I
         //
         _identities.insert(proxy->ice_getIdentity());
     }
-    
+
     //
     // We also must remove whatever proxies the router evicted.
     //

data/ext/ice/cpp/src/Ice/RouterInfo.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.
@@ -10,15 +10,15 @@
 #ifndef ICE_ROUTER_INFO_H
 #define ICE_ROUTER_INFO_H
 
-#include <IceUtil/Shared.h>
 #include <IceUtil/Mutex.h>
 #include <Ice/RouterInfoF.h>
-#include <Ice/RouterF.h>
+#include <Ice/Router.h>
 #include <Ice/ProxyF.h>
 #include <Ice/ReferenceF.h>
 #include <Ice/EndpointIF.h>
 #include <Ice/BuiltinSequences.h>
 #include <Ice/Identity.h>
+#include <Ice/Comparable.h>
 
 #include <set>
 
@@ -37,89 +37,99 @@ public:
     // Returns router info for a given router. Automatically creates
     // the router info if it doesn't exist yet.
     //
-    RouterInfoPtr get(const Ice::RouterPrx&);
-    RouterInfoPtr erase(const Ice::RouterPrx&);
+    RouterInfoPtr get(const Ice::RouterPrxPtr&);
+    RouterInfoPtr erase(const Ice::RouterPrxPtr&);
 
 private:
 
-    std::map<Ice::RouterPrx, RouterInfoPtr> _table;
-    std::map<Ice::RouterPrx, RouterInfoPtr>::iterator _tableHint;
+#ifdef ICE_CPP11_MAPPING
+    using RouterInfoTable = std::map<std::shared_ptr<Ice::RouterPrx>,
+                                     RouterInfoPtr,
+                                     Ice::TargetCompare<std::shared_ptr<Ice::RouterPrx>, std::less>>;
+#else
+    typedef std::map<Ice::RouterPrx, RouterInfoPtr> RouterInfoTable;
+#endif
+
+    RouterInfoTable _table;
+    RouterInfoTable::iterator _tableHint;
 };
 
 class RouterInfo : public IceUtil::Shared, public IceUtil::Mutex
 {
 public:
 
-    class GetClientEndpointsCallback : virtual public Ice::LocalObject
+    class GetClientEndpointsCallback : public virtual Ice::LocalObject
     {
     public:
-        
+
         virtual void setEndpoints(const std::vector<EndpointIPtr>&) = 0;
         virtual void setException(const Ice::LocalException&) = 0;
     };
     typedef IceUtil::Handle<GetClientEndpointsCallback> GetClientEndpointsCallbackPtr;
 
-    class AddProxyCallback : virtual public IceUtil::Shared
+    class AddProxyCallback
+#ifndef ICE_CPP11_MAPPING
+        : public virtual IceUtil::Shared
+#endif
     {
     public:
-        
+
         virtual void addedProxy() = 0;
         virtual void setException(const Ice::LocalException&) = 0;
     };
-    typedef IceUtil::Handle<AddProxyCallback> AddProxyCallbackPtr; 
+    ICE_DEFINE_PTR(AddProxyCallbackPtr, AddProxyCallback);
 
-    RouterInfo(const Ice::RouterPrx&);
+    RouterInfo(const Ice::RouterPrxPtr&);
 
     void destroy();
 
     bool operator==(const RouterInfo&) const;
-    bool operator!=(const RouterInfo&) const;
     bool operator<(const RouterInfo&) const;
 
-    const Ice::RouterPrx& getRouter() const
+    const Ice::RouterPrxPtr& getRouter() const
     {
         //
         // No mutex lock necessary, _router is immutable.
         //
         return _router;
     }
-    void getClientProxyResponse(const Ice::ObjectPrx&, const GetClientEndpointsCallbackPtr&);
+    void getClientProxyResponse(const Ice::ObjectPrxPtr&, const IceUtil::Optional<bool>&,
+                                const GetClientEndpointsCallbackPtr&);
     void getClientProxyException(const Ice::Exception&, const GetClientEndpointsCallbackPtr&);
     std::vector<EndpointIPtr> getClientEndpoints();
     void getClientEndpoints(const GetClientEndpointsCallbackPtr&);
     std::vector<EndpointIPtr> getServerEndpoints();
-    
+
     class AddProxyCookie : public Ice::LocalObject
     {
     public:
-        
-        AddProxyCookie(const AddProxyCallbackPtr cb, const Ice::ObjectPrx& proxy) :
+
+        AddProxyCookie(const AddProxyCallbackPtr cb, const Ice::ObjectPrxPtr& proxy) :
             _cb(cb),
             _proxy(proxy)
         {
         }
-        
+
         AddProxyCallbackPtr cb() const
         {
             return _cb;
         }
-        
-        Ice::ObjectPrx proxy() const
+
+        Ice::ObjectPrxPtr proxy() const
         {
             return _proxy;
         }
-        
+
     private:
-        
+
         const AddProxyCallbackPtr _cb;
-        const Ice::ObjectPrx _proxy;
+        const Ice::ObjectPrxPtr _proxy;
     };
     typedef IceUtil::Handle<AddProxyCookie> AddProxyCookiePtr;
-    
+
     void addProxyResponse(const Ice::ObjectProxySeq&, const AddProxyCookiePtr&);
     void addProxyException(const Ice::Exception&, const AddProxyCookiePtr&);
-    void addProxy(const Ice::ObjectPrx&);
-    bool addProxy(const Ice::ObjectPrx&, const AddProxyCallbackPtr&);
+    bool addProxy(const Ice::ObjectPrxPtr&, const AddProxyCallbackPtr&);
 
     void setAdapter(const Ice::ObjectAdapterPtr&);
     Ice::ObjectAdapterPtr getAdapter() const;
@@ -129,15 +139,16 @@ public:
     //
     // The following methods need to be public for access by AMI callbacks.
     //
-    std::vector<EndpointIPtr> setClientEndpoints(const Ice::ObjectPrx&);
-    std::vector<EndpointIPtr> setServerEndpoints(const Ice::ObjectPrx&);
-    void addAndEvictProxies(const Ice::ObjectPrx&, const Ice::ObjectProxySeq&);
+    std::vector<EndpointIPtr> setClientEndpoints(const Ice::ObjectPrxPtr&, bool);
+    std::vector<EndpointIPtr> setServerEndpoints(const Ice::ObjectPrxPtr&);
+    void addAndEvictProxies(const Ice::ObjectPrxPtr&, const Ice::ObjectProxySeq&);
 
 private:
 
-    const Ice::RouterPrx _router;
+    const Ice::RouterPrxPtr _router;
     std::vector<EndpointIPtr> _clientEndpoints;
     std::vector<EndpointIPtr> _serverEndpoints;
+    bool _hasRoutingTable;
     Ice::ObjectAdapterPtr _adapter;
     std::set<Ice::Identity> _identities;
     std::multiset<Ice::Identity> _evictedIdentities;