zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Ice/LocatorF.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/LocatorF.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/LocatorInfo.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.
@@ -18,6 +18,7 @@
 #include <Ice/Reference.h>
 #include <Ice/Functional.h>
 #include <Ice/Properties.h>
+#include <Ice/Comparable.h>
 #include <iterator>
 
 using namespace std;
@@ -44,11 +45,32 @@ public:
     {
         try
         {
+#ifdef ICE_CPP11_MAPPING
+            LocatorInfo::RequestPtr request = this;
+            _locatorInfo->getLocator()->findObjectByIdAsync(
+                _ref->getIdentity(),
+                [request](const ObjectPrxPtr& object)
+                {
+                    request->response(object);
+                },
+                [request](exception_ptr e)
+                {
+                    try
+                    {
+                        rethrow_exception(e);
+                    }
+                    catch(const Exception& ex)
+                    {
+                        request->exception(ex);
+                    }
+                });
+#else
             _locatorInfo->getLocator()->begin_findObjectById(
                 _ref->getIdentity(),
                 newCallback_Locator_findObjectById(static_cast<LocatorInfo::Request*>(this),
                                                    &LocatorInfo::Request::response,
                                                    &LocatorInfo::Request::exception));
+#endif
         }
         catch(const Ice::Exception& ex)
         {
@@ -70,11 +92,31 @@ public:
     {
         try
         {
+#ifdef ICE_CPP11_MAPPING
+            LocatorInfo::RequestPtr request = this;
+            _locatorInfo->getLocator()->findAdapterByIdAsync(_ref->getAdapterId(),
+                [request](const shared_ptr<Ice::ObjectPrx>& object)
+                {
+                    request->response(object);
+                },
+                [request](exception_ptr e)
+                {
+                    try
+                    {
+                        rethrow_exception(e);
+                    }
+                    catch(const Exception& ex)
+                    {
+                        request->exception(ex);
+                    }
+                });
+#else
             _locatorInfo->getLocator()->begin_findAdapterById(
                 _ref->getAdapterId(),
                 newCallback_Locator_findAdapterById(static_cast<LocatorInfo::Request*>(this),
                                                     &LocatorInfo::Request::response,
                                                     &LocatorInfo::Request::exception));
+#endif
         }
         catch(const Ice::Exception& ex)
         {
@@ -96,8 +138,11 @@ IceInternal::LocatorManager::destroy()
 {
     IceUtil::Mutex::Lock sync(*this);
 
+#ifdef ICE_CPP11_MAPPING
+    for_each(_table.begin(), _table.end(), [](pair<shared_ptr<Ice::LocatorPrx>, LocatorInfoPtr> it){ it.second->destroy(); });
+#else
     for_each(_table.begin(), _table.end(), Ice::secondVoidMemFun<const LocatorPrx, LocatorInfo>(&LocatorInfo::destroy));
-
+#endif
     _table.clear();
     _tableHint = _table.end();
 
@@ -105,14 +150,14 @@ IceInternal::LocatorManager::destroy()
 }
 
 LocatorInfoPtr
-IceInternal::LocatorManager::get(const LocatorPrx& loc)
+IceInternal::LocatorManager::get(const LocatorPrxPtr& loc)
 {
     if(!loc)
     {
         return 0;
     }
 
-    LocatorPrx locator = LocatorPrx::uncheckedCast(loc->ice_locator(0)); // The locator can't be located.
+    LocatorPrxPtr locator = loc->ice_locator(0); // The locator can't be located.
 
     //
     // TODO: reap unused locator info objects?
@@ -120,11 +165,11 @@ IceInternal::LocatorManager::get(const LocatorPrx& loc)
 
     IceUtil::Mutex::Lock sync(*this);
 
-    map<LocatorPrx, LocatorInfoPtr>::iterator p = _table.end();
+    LocatorInfoTable::iterator p = _table.end();
 
     if(_tableHint != _table.end())
     {
-        if(_tableHint->first == locator)
+        if(targetEqualTo(_tableHint->first, locator))
         {
             p = _tableHint;
         }
@@ -152,7 +197,7 @@ IceInternal::LocatorManager::get(const LocatorPrx& loc)
         }
 
         _tableHint = _table.insert(_tableHint,
-                                   pair<const LocatorPrx, LocatorInfoPtr>(locator,
+                                   pair<const LocatorPrxPtr, LocatorInfoPtr>(locator,
                                                                           new LocatorInfo(locator, t->second,
                                                                                           _background)));
     }
@@ -301,12 +346,12 @@ IceInternal::LocatorTable::checkTTL(const IceUtil::Time& time, int ttl) const
 }
 
 void
-IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locatorInfo, const Ice::ObjectPrx& proxy)
+IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locatorInfo, const Ice::ObjectPrxPtr& proxy)
 {
     vector<EndpointIPtr> endpoints;
     if(proxy)
     {
-        ReferencePtr r = proxy->__reference();
+        ReferencePtr r = proxy->_getReference();
         if(_ref->isWellKnown() && !isSupported(_ref->getEncoding(), r->getEncoding()))
         {
             //
@@ -326,7 +371,12 @@ IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locato
             // by the locator is an indirect proxy. We now need to resolve the endpoints
             // of this indirect proxy.
             //
-            locatorInfo->getEndpointsWithCallback(r, _ref, _ttl, _callback);
+            if(_ref->getInstance()->traceLevels()->location >= 1)
+            {
+                locatorInfo->trace("retrieved adapter for well-known object from locator, adding to locator cache",
+                                   _ref, r);
+            }
+            locatorInfo->getEndpoints(r, _ref, _ttl, _callback);
             return;
         }
     }
@@ -373,7 +423,7 @@ IceInternal::LocatorInfo::Request::addCallback(const ReferencePtr& ref,
     RequestCallbackPtr callback = new RequestCallback(ref, ttl, cb);
     {
         IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-        if(!_response && !_exception.get())
+        if(!_response && !_exception)
         {
             _callbacks.push_back(callback);
             if(wellKnownRef) // This request is to resolve the endpoints of a cached well-known object reference
@@ -396,69 +446,9 @@ IceInternal::LocatorInfo::Request::addCallback(const ReferencePtr& ref,
     }
     else
     {
-        assert(_exception.get());
-        callback->exception(_locatorInfo, *_exception.get());
-    }
-}
-
-vector<EndpointIPtr>
-IceInternal::LocatorInfo::Request::getEndpoints(const ReferencePtr& ref,
-                                                const ReferencePtr& wellKnownRef,
-                                                int ttl,
-                                                bool& cached)
-{
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-    if(!_response && !_exception.get())
-    {
-        if(wellKnownRef) // This request is to resolve the endpoints of a cached well-known object reference
-        {
-            _wellKnownRefs.push_back(wellKnownRef);
-        }
-        if(!_sent)
-        {
-            _sent = true;
-            sync.release();
-            send(); // send() might call exception() from this thread so we need to release the mutex.
-            sync.acquire();
-        }
-
-        while(!_response && !_exception.get())
-        {
-            _monitor.wait();
-        }
-    }
-
-    if(_exception.get())
-    {
-        _locatorInfo->getEndpointsException(ref, *_exception.get()); // This throws.
-    }
-
-    assert(_response);
-    vector<EndpointIPtr> endpoints;
-    if(_proxy)
-    {
-        ReferencePtr r = _proxy->__reference();
-        if(!r->isIndirect())
-        {
-            endpoints = r->getEndpoints();
-        }
-        else if(ref->isWellKnown() && !r->isWellKnown())
-        {
-            //
-            // We're resolving the endpoints of a well-known object and the proxy returned
-            // by the locator is an indirect proxy. We now need to resolve the endpoints
-            // of this indirect proxy.
-            //
-            return _locatorInfo->getEndpoints(r, ref, ttl, cached);
-        }
-    }
-
-    cached = false;
-    if(_ref->getInstance()->traceLevels()->location >= 1)
-    {
-        _locatorInfo->getEndpointsTrace(ref, endpoints, false);
+        assert(_exception);
+        callback->exception(_locatorInfo, *_exception);
     }
-    return endpoints;
 }
 
 IceInternal::LocatorInfo::Request::Request(const LocatorInfoPtr& locatorInfo, const ReferencePtr& ref) :
@@ -467,7 +457,7 @@ IceInternal::LocatorInfo::Request::Request(const LocatorInfoPtr& locatorInfo, co
 }
 
 void
-IceInternal::LocatorInfo::Request::response(const Ice::ObjectPrx& proxy)
+IceInternal::LocatorInfo::Request::response(const Ice::ObjectPrxPtr& proxy)
 {
     {
         IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
@@ -488,7 +478,8 @@ IceInternal::LocatorInfo::Request::exception(const Ice::Exception& ex)
     {
         IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
         _locatorInfo->finishRequest(_ref, _wellKnownRefs, 0, dynamic_cast<const Ice::UserException*>(&ex));
-        _exception.reset(ex.ice_clone());
+
+        ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone());
         _monitor.notifyAll();
     }
     for(vector<RequestCallbackPtr>::const_iterator p = _callbacks.begin(); p != _callbacks.end(); ++p)
@@ -497,7 +488,7 @@ IceInternal::LocatorInfo::Request::exception(const Ice::Exception& ex)
     }
 }
 
-IceInternal::LocatorInfo::LocatorInfo(const LocatorPrx& locator, const LocatorTablePtr& table, bool background) :
+IceInternal::LocatorInfo::LocatorInfo(const LocatorPrxPtr& locator, const LocatorTablePtr& table, bool background) :
     _locator(locator),
     _table(table),
     _background(background)
@@ -518,22 +509,16 @@ IceInternal::LocatorInfo::destroy()
 bool
 IceInternal::LocatorInfo::operator==(const LocatorInfo& rhs) const
 {
-    return _locator == rhs._locator;
-}
-
-bool
-IceInternal::LocatorInfo::operator!=(const LocatorInfo& rhs) const
-{
-    return _locator != rhs._locator;
+    return Ice::targetEqualTo(_locator, rhs._locator);
 }
 
 bool
 IceInternal::LocatorInfo::operator<(const LocatorInfo& rhs) const
 {
-    return _locator < rhs._locator;
+    return Ice::targetLess(_locator, rhs._locator);
 }
 
-LocatorRegistryPrx
+LocatorRegistryPrxPtr
 IceInternal::LocatorInfo::getLocatorRegistry()
 {
     {
@@ -547,7 +532,7 @@ IceInternal::LocatorInfo::getLocatorRegistry()
     //
     // Do not make locator calls from within sync.
     //
-    LocatorRegistryPrx locatorRegistry = _locator->getRegistry();
+    LocatorRegistryPrxPtr locatorRegistry = _locator->getRegistry();
     if(!locatorRegistry)
     {
         return 0;
@@ -561,69 +546,16 @@ IceInternal::LocatorInfo::getLocatorRegistry()
         // endpoint selection in case the locator returned a proxy
         // with some endpoints which are prefered to be tried first.
         //
-        _locatorRegistry = locatorRegistry->ice_locator(0)->ice_endpointSelection(Ice::Ordered);
+        _locatorRegistry = locatorRegistry->ice_locator(0)->ice_endpointSelection(Ice::ICE_ENUM(EndpointSelectionType, Ordered));
         return _locatorRegistry;
     }
 }
 
-vector<EndpointIPtr>
-IceInternal::LocatorInfo::getEndpoints(const ReferencePtr& ref, const ReferencePtr& wellKnownRef, int ttl, bool& cached)
-{
-    assert(ref->isIndirect());
-    vector<EndpointIPtr> endpoints;
-    if(!ref->isWellKnown())
-    {
-        if(!_table->getAdapterEndpoints(ref->getAdapterId(), ttl, endpoints))
-        {
-            if(_background && !endpoints.empty())
-            {
-                getAdapterRequest(ref)->addCallback(ref, wellKnownRef, ttl, 0);
-            }
-            else
-            {
-                return getAdapterRequest(ref)->getEndpoints(ref, wellKnownRef, ttl, cached);
-            }
-        }
-    }
-    else
-    {
-        ReferencePtr r;
-        if(!_table->getObjectReference(ref->getIdentity(), ttl, r))
-        {
-            if(_background && r)
-            {
-                getObjectRequest(ref)->addCallback(ref, 0, ttl, 0);
-            }
-            else
-            {
-                return getObjectRequest(ref)->getEndpoints(ref, 0, ttl, cached);
-            }
-        }
-
-        if(!r->isIndirect())
-        {
-            endpoints = r->getEndpoints();
-        }
-        else if(!r->isWellKnown())
-        {
-            return getEndpoints(r, ref, ttl, cached);
-        }
-    }
-
-    assert(!endpoints.empty());
-    cached = true;
-    if(ref->getInstance()->traceLevels()->location >= 1)
-    {
-        getEndpointsTrace(ref, endpoints, true);
-    }
-    return endpoints;
-}
-
 void
-IceInternal::LocatorInfo::getEndpointsWithCallback(const ReferencePtr& ref,
-                                                   const ReferencePtr& wellKnownRef,
-                                                   int ttl,
-                                                   const GetEndpointsCallbackPtr& callback)
+IceInternal::LocatorInfo::getEndpoints(const ReferencePtr& ref,
+                                       const ReferencePtr& wellKnownRef,
+                                       int ttl,
+                                       const GetEndpointsCallbackPtr& callback)
 {
     assert(ref->isIndirect());
     vector<EndpointIPtr> endpoints;
@@ -664,7 +596,11 @@ IceInternal::LocatorInfo::getEndpointsWithCallback(const ReferencePtr& ref,
         }
         else if(!r->isWellKnown())
         {
-            getEndpointsWithCallback(r, ref, ttl, callback);
+            if(ref->getInstance()->traceLevels()->location >= 1)
+            {
+                trace("found adapter for well-known object in locator cache", ref, r);
+            }
+            getEndpoints(r, ref, ttl, callback);
             return;
         }
     }
@@ -691,7 +627,7 @@ IceInternal::LocatorInfo::clearCache(const ReferencePtr& ref)
 
         if(!endpoints.empty() && ref->getInstance()->traceLevels()->location >= 2)
         {
-            trace("removed endpoints from locator table", ref, endpoints);
+            trace("removed endpoints for adapter from locator cache", ref, endpoints);
         }
     }
     else
@@ -703,11 +639,15 @@ IceInternal::LocatorInfo::clearCache(const ReferencePtr& ref)
             {
                 if(ref->getInstance()->traceLevels()->location >= 2)
                 {
-                    trace("removed endpoints from locator table", ref, r->getEndpoints());
+                    trace("removed endpoints for well-known object from locator cache", ref, r->getEndpoints());
                 }
             }
             else if(!r->isWellKnown())
             {
+                if(ref->getInstance()->traceLevels()->location >= 2)
+                {
+                    trace("removed adapter for well-known object from locator cache", ref, r);
+                }
                 clearCache(r);
             }
         }
@@ -745,12 +685,13 @@ IceInternal::LocatorInfo::getEndpointsException(const ReferencePtr& ref, const I
             Trace out(ref->getInstance()->initializationData().logger,
                       ref->getInstance()->traceLevels()->locationCat);
             out << "object not found" << "\n";
-            out << "object = " << ref->getInstance()->identityToString(ref->getIdentity());
+            out << "object = " << Ice::identityToString(ref->getIdentity(),
+                                                        ref->getInstance()->toStringMode());
         }
 
         NotRegisteredException ex(__FILE__, __LINE__);
         ex.kindOfObject = "object";
-        ex.id = ref->getInstance()->identityToString(ref->getIdentity());
+        ex.id = Ice::identityToString(ref->getIdentity(), ref->getInstance()->toStringMode());
         throw ex;
     }
     catch(const NotRegisteredException&)
@@ -762,10 +703,10 @@ IceInternal::LocatorInfo::getEndpointsException(const ReferencePtr& ref, const I
         if(ref->getInstance()->traceLevels()->location >= 1)
         {
             Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
-            out << "couldn't contact the locator to retrieve adapter endpoints\n";
+            out << "couldn't contact the locator to retrieve endpoints\n";
             if(ref->getAdapterId().empty())
             {
-                out << "object = " << ref->getInstance()->identityToString(ref->getIdentity()) << "\n";
+                out << "well-known proxy = " << ref->toString() << "\n";
             }
             else
             {
@@ -786,11 +727,25 @@ IceInternal::LocatorInfo::getEndpointsTrace(const ReferencePtr& ref,
     {
         if(cached)
         {
-            trace("found endpoints in locator table", ref, endpoints);
+            if(ref->isWellKnown())
+            {
+                trace("found endpoints for well-known proxy in locator cache", ref, endpoints);
+            }
+            else
+            {
+                trace("found endpoints for adapter in locator cache", ref, endpoints);
+            }
         }
         else
         {
-            trace("retrieved endpoints from locator, adding to locator table", ref, endpoints);
+            if(ref->isWellKnown())
+            {
+                trace("retrieved endpoints for well-known proxy from locator, adding to locator cache", ref, endpoints);
+            }
+            else
+            {
+                trace("retrieved endpoints for adapter from locator, adding to locator cache", ref, endpoints);
+            }
         }
     }
     else
@@ -799,8 +754,8 @@ IceInternal::LocatorInfo::getEndpointsTrace(const ReferencePtr& ref,
         out << "no endpoints configured for ";
         if(ref->getAdapterId().empty())
         {
-            out << "object\n";
-            out << "object = " << ref->getInstance()->identityToString(ref->getIdentity());
+            out << "well-known object\n";
+            out << "well-known proxy = " << ref->toString();
         }
         else
         {
@@ -823,7 +778,7 @@ IceInternal::LocatorInfo::trace(const string& msg, const ReferencePtr& ref, cons
     }
     else
     {
-        out << "object = "  << ref->getInstance()->identityToString(ref->getIdentity()) << '\n';
+        out << "well-known proxy = "  << ref->toString() << '\n';
     }
 
     const char* sep = endpoints.size() > 1 ? ":" : "";
@@ -833,6 +788,17 @@ IceInternal::LocatorInfo::trace(const string& msg, const ReferencePtr& ref, cons
     out << "endpoints = " << o.str();
 }
 
+void
+IceInternal::LocatorInfo::trace(const string& msg, const ReferencePtr& ref, const ReferencePtr& resolved)
+{
+    assert(ref->isWellKnown());
+
+    Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
+    out << msg << '\n';
+    out << "well-known proxy = "  << ref->toString() << '\n';
+    out << "adapter = " << resolved->getAdapterId();
+}
+
 IceInternal::LocatorInfo::RequestPtr
 IceInternal::LocatorInfo::getAdapterRequest(const ReferencePtr& ref)
 {
@@ -861,7 +827,7 @@ IceInternal::LocatorInfo::getObjectRequest(const ReferencePtr& ref)
     if(ref->getInstance()->traceLevels()->location >= 1)
     {
         Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
-        out << "searching for object by id\nobject = " << ref->getInstance()->identityToString(ref->getIdentity());
+        out << "searching for well-known object\nwell-known proxy = " << ref->toString();
     }
 
     map<Ice::Identity, RequestPtr>::const_iterator p = _objectRequests.find(ref->getIdentity());
@@ -877,10 +843,10 @@ IceInternal::LocatorInfo::getObjectRequest(const ReferencePtr& ref)
 void
 IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref,
                                         const vector<ReferencePtr>& wellKnownRefs,
-                                        const Ice::ObjectPrx& proxy,
+                                        const Ice::ObjectPrxPtr& proxy,
                                         bool notRegistered)
 {
-    if(!proxy || proxy->__reference()->isIndirect())
+    if(!proxy || proxy->_getReference()->isIndirect())
     {
         //
         // Remove the cached references of well-known objects for which we tried
@@ -894,9 +860,9 @@ IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref,
 
     if(!ref->isWellKnown())
     {
-        if(proxy && !proxy->__reference()->isIndirect()) // Cache the adapter endpoints.
+        if(proxy && !proxy->_getReference()->isIndirect()) // Cache the adapter endpoints.
         {
-            _table->addAdapterEndpoints(ref->getAdapterId(), proxy->__reference()->getEndpoints());
+            _table->addAdapterEndpoints(ref->getAdapterId(), proxy->_getReference()->getEndpoints());
         }
         else if(notRegistered) // If the adapter isn't registered anymore, remove it from the cache.
         {
@@ -909,9 +875,9 @@ IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref,
     }
     else
     {
-        if(proxy && !proxy->__reference()->isWellKnown()) // Cache the well-known object reference.
+        if(proxy && !proxy->_getReference()->isWellKnown()) // Cache the well-known object reference.
         {
-            _table->addObjectReference(ref->getIdentity(), proxy->__reference());
+            _table->addObjectReference(ref->getIdentity(), proxy->_getReference());
         }
         else if(notRegistered) // If the well-known object isn't registered anymore, remove it from the cache.
         {