zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Ice/ProxyFactory.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.
@@ -15,7 +15,8 @@
 #include <Ice/ReferenceFactory.h>
 #include <Ice/LocatorInfo.h>
 #include <Ice/RouterInfo.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/Properties.h>
 #include <Ice/LoggerUtil.h>
 #include <Ice/TraceLevels.h>
@@ -28,7 +29,7 @@ using namespace IceInternal;
 
 IceUtil::Shared* IceInternal::upCast(ProxyFactory* p) { return p; }
 
-ObjectPrx
+ObjectPrxPtr
 IceInternal::ProxyFactory::stringToProxy(const string& str) const
 {
     ReferencePtr ref = _instance->referenceFactory()->create(str, "");
@@ -36,11 +37,11 @@ IceInternal::ProxyFactory::stringToProxy(const string& str) const
 }
 
 string
-IceInternal::ProxyFactory::proxyToString(const ObjectPrx& proxy) const
+IceInternal::ProxyFactory::proxyToString(const ObjectPrxPtr& proxy) const
 {
     if(proxy)
     {
-        return proxy->__reference()->toString();
+        return proxy->_getReference()->toString();
     }
     else
     {
@@ -48,7 +49,7 @@ IceInternal::ProxyFactory::proxyToString(const ObjectPrx& proxy) const
     }
 }
 
-ObjectPrx
+ObjectPrxPtr
 IceInternal::ProxyFactory::propertyToProxy(const string& prefix) const
 {
     string proxy = _instance->initializationData().properties->getProperty(prefix);
@@ -57,11 +58,11 @@ IceInternal::ProxyFactory::propertyToProxy(const string& prefix) const
 }
 
 PropertyDict
-IceInternal::ProxyFactory::proxyToProperty(const ObjectPrx& proxy, const string& prefix) const
+IceInternal::ProxyFactory::proxyToProperty(const ObjectPrxPtr& proxy, const string& prefix) const
 {
     if(proxy)
     {
-        return proxy->__reference()->toProperty(prefix);
+        return proxy->_getReference()->toProperty(prefix);
     }
     else
     {
@@ -69,8 +70,8 @@ IceInternal::ProxyFactory::proxyToProperty(const ObjectPrx& proxy, const string&
     }
 }
 
-ObjectPrx
-IceInternal::ProxyFactory::streamToProxy(BasicStream* s) const
+ObjectPrxPtr
+IceInternal::ProxyFactory::streamToProxy(InputStream* s) const
 {
     Identity ident;
     s->read(ident);
@@ -79,33 +80,22 @@ IceInternal::ProxyFactory::streamToProxy(BasicStream* s) const
     return referenceToProxy(ref);
 }
 
-void
-IceInternal::ProxyFactory::proxyToStream(const ObjectPrx& proxy, BasicStream* s) const
-{
-    if(proxy)
-    {
-        s->write(proxy->__reference()->getIdentity());
-        proxy->__reference()->streamWrite(s);
-    }
-    else
-    {
-        Identity ident;
-        s->write(ident);
-    }
-}
-
-ObjectPrx
+ObjectPrxPtr
 IceInternal::ProxyFactory::referenceToProxy(const ReferencePtr& ref) const
 {
     if(ref)
     {
-        ObjectPrx proxy = new ::IceProxy::Ice::Object;
+#ifdef ICE_CPP11_MAPPING
+        auto proxy = createProxy<ObjectPrx>();
+#else
+        ObjectPrx proxy = new ::IceProxy::Ice::Object();
+#endif
         proxy->setup(ref);
         return proxy;
     }
     else
     {
-        return 0;
+        return ICE_NULLPTR;
     }
 }
 
@@ -211,11 +201,12 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co
     }
 
     //
-    // Don't retry if the communicator is destroyed or object adapter
-    // deactivated.
+    // Don't retry if the communicator is destroyed, object adapter is deactivated,
+    // or connection is manually closed.
     //
     if(dynamic_cast<const CommunicatorDestroyedException*>(&ex) ||
-       dynamic_cast<const ObjectAdapterDeactivatedException*>(&ex))
+       dynamic_cast<const ObjectAdapterDeactivatedException*>(&ex) ||
+       dynamic_cast<const ConnectionManuallyClosedException*>(&ex))
     {
         ex.ice_throw();
     }
@@ -239,7 +230,7 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co
         // limit is reached.
         //
         interval = 0;
-    } 
+    }
     else if(cnt > static_cast<int>(_retryIntervals.size()))
     {
         if(traceLevels->retry >= 1)

data/ext/ice/cpp/src/Ice/ProxyFactory.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.
@@ -20,25 +20,30 @@
 #include <Ice/OutgoingAsyncF.h>
 #include <Ice/Properties.h>
 
-namespace IceInternal
+namespace Ice
 {
 
-class BasicStream;
+class OutputStream;
+class InputStream;
+
+}
+
+namespace IceInternal
+{
 
 class ProxyFactory : public IceUtil::Shared
 {
 public:
-    
-    Ice::ObjectPrx stringToProxy(const std::string&) const;
-    std::string proxyToString(const Ice::ObjectPrx&) const;
 
-    Ice::ObjectPrx propertyToProxy(const std::string&) const;
-    Ice::PropertyDict proxyToProperty(const Ice::ObjectPrx&, const std::string&) const;
+    Ice::ObjectPrxPtr stringToProxy(const std::string&) const;
+    std::string proxyToString(const Ice::ObjectPrxPtr&) const;
+
+    Ice::ObjectPrxPtr propertyToProxy(const std::string&) const;
+    Ice::PropertyDict proxyToProperty(const Ice::ObjectPrxPtr&, const std::string&) const;
 
-    Ice::ObjectPrx streamToProxy(BasicStream*) const;
-    void proxyToStream(const Ice::ObjectPrx&, BasicStream*) const;
+    Ice::ObjectPrxPtr streamToProxy(Ice::InputStream*) const;
 
-    Ice::ObjectPrx referenceToProxy(const ReferencePtr&) const;
+    Ice::ObjectPrxPtr referenceToProxy(const ReferencePtr&) const;
 
     int checkRetryAfterException(const Ice::LocalException&, const ReferencePtr&, int&) const;
 

data/ext/ice/cpp/src/Ice/Reference.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.
@@ -13,7 +13,7 @@
 #include <Ice/Instance.h>
 #include <Ice/EndpointI.h>
 #include <Ice/OpaqueEndpointI.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
 #include <Ice/RouterInfo.h>
 #include <Ice/Router.h>
 #include <Ice/LocatorInfo.h>
@@ -27,11 +27,14 @@
 #include <Ice/RequestHandlerFactory.h>
 #include <Ice/ConnectionRequestHandler.h>
 #include <Ice/DefaultsAndOverrides.h>
-#include <IceUtil/StringUtil.h>
+#include <Ice/Comparable.h>
+#include <Ice/StringUtil.h>
+
 #include <IceUtil/Random.h>
 #include <IceUtil/MutexPtrLock.h>
 
 #include <functional>
+#include <algorithm>
 
 using namespace std;
 using namespace Ice;
@@ -171,6 +174,25 @@ IceInternal::Reference::changeCompress(bool newCompress) const
     return r;
 }
 
+bool
+IceInternal::Reference::getCompressOverride(bool& compress) const
+{
+    DefaultsAndOverridesPtr defaultsAndOverrides = getInstance()->defaultsAndOverrides();
+    if(defaultsAndOverrides->overrideCompress)
+    {
+        compress = defaultsAndOverrides->overrideCompressValue;
+    }
+    else if(_overrideCompress)
+    {
+        compress = _compress;
+    }
+    else
+    {
+        return false;
+    }
+    return true;
+}
+
 Int
 Reference::hash() const
 {
@@ -184,7 +206,7 @@ Reference::hash() const
 }
 
 void
-IceInternal::Reference::streamWrite(BasicStream* s) const
+IceInternal::Reference::streamWrite(OutputStream* s) const
 {
     //
     // Don't write the identity here. Operations calling streamWrite
@@ -207,7 +229,7 @@ IceInternal::Reference::streamWrite(BasicStream* s) const
 
     s->write(_secure);
 
-    if(s->getWriteEncoding() != Ice::Encoding_1_0)
+    if(s->getEncoding() != Ice::Encoding_1_0)
     {
         s->write(_protocol);
         s->write(_encoding);
@@ -228,13 +250,18 @@ IceInternal::Reference::toString() const
     //
     ostringstream s;
 
+    ToStringMode toStringMode = _instance->toStringMode();
+    const string separators = " :@";
+
+    string id = Ice::identityToString(_identity, toStringMode);
+
     //
     // If the encoded identity string contains characters which
     // the reference parser uses as separators, then we enclose
     // the identity string in quotes.
     //
-    string id = _instance->identityToString(_identity);
-    if(id.find_first_of(" :@") != string::npos)
+
+    if(id.find_first_of(separators) != string::npos)
     {
         s << '"' << id << '"';
     }
@@ -247,14 +274,13 @@ IceInternal::Reference::toString() const
     {
         s << " -f ";
 
+        string fs = escapeString(_facet, "", toStringMode);
         //
         // If the encoded facet string contains characters which
         // the reference parser uses as separators, then we enclose
         // the facet string in quotes.
         //
-        string fs = nativeToUTF8(_facet, _instance->getStringConverter());
-        fs = IceUtilInternal::escapeString(fs, "");
-        if(fs.find_first_of(" :@") != string::npos)
+        if(fs.find_first_of(separators) != string::npos)
         {
             s << '"' << fs << '"';
         }
@@ -376,16 +402,9 @@ IceInternal::Reference::operator==(const Reference& r) const
     {
         return false;
     }
-
     return true;
 }
 
-bool
-IceInternal::Reference::operator!=(const Reference& r) const
-{
-    return !operator==(r);
-}
-
 bool
 IceInternal::Reference::operator<(const Reference& r) const
 {
@@ -624,7 +643,7 @@ IceInternal::FixedReference::getPreferSecure() const
 Ice::EndpointSelectionType
 IceInternal::FixedReference::getEndpointSelection() const
 {
-    return Random;
+    return ICE_ENUM(EndpointSelectionType, Random);
 }
 
 int
@@ -654,14 +673,14 @@ IceInternal::FixedReference::changeAdapterId(const string& /*newAdapterId*/) con
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeLocator(const LocatorPrx&) const
+IceInternal::FixedReference::changeLocator(const LocatorPrxPtr&) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
     return 0; // Keep the compiler happy.
 }
 
 ReferencePtr
-IceInternal::FixedReference::changeRouter(const RouterPrx&) const
+IceInternal::FixedReference::changeRouter(const RouterPrxPtr&) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
     return 0; // Keep the compiler happy.
@@ -729,18 +748,9 @@ IceInternal::FixedReference::isWellKnown() const
 }
 
 void
-IceInternal::FixedReference::streamWrite(BasicStream*) const
-{
-    throw FixedProxyException(__FILE__, __LINE__);
-}
-
-string
-IceInternal::FixedReference::toString() const
+IceInternal::FixedReference::streamWrite(OutputStream*) const
 {
     throw FixedProxyException(__FILE__, __LINE__);
-
-    assert(false);   // Cannot be reached.
-    return string(); // To keep the compiler from complaining.
 }
 
 PropertyDict
@@ -753,7 +763,7 @@ IceInternal::FixedReference::toProperty(const string&) const
 }
 
 RequestHandlerPtr
-IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrx& proxy) const
+IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrxPtr& proxy) const
 {
     switch(getMode())
     {
@@ -800,7 +810,7 @@ IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrx& proxy) cons
 
     _fixedConnection->throwException(); // Throw in case our connection is already destroyed.
 
-    bool compress;
+    bool compress = false;
     if(defaultsAndOverrides->overrideCompress)
     {
         compress = defaultsAndOverrides->overrideCompressValue;
@@ -809,13 +819,9 @@ IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrx& proxy) cons
     {
         compress = _compress;
     }
-    else
-    {
-        compress = _fixedConnection->endpoint()->compress();
-    }
 
     ReferencePtr ref = const_cast<FixedReference*>(this);
-    return proxy->__setRequestHandler(new ConnectionRequestHandler(ref, _fixedConnection, compress));
+    return proxy->_setRequestHandler(ICE_MAKE_SHARED(ConnectionRequestHandler, ref, _fixedConnection, compress));
 }
 
 BatchRequestQueuePtr
@@ -839,12 +845,6 @@ IceInternal::FixedReference::operator==(const Reference& r) const
     return _fixedConnection == rhs->_fixedConnection;
 }
 
-bool
-IceInternal::FixedReference::operator!=(const Reference& r) const
-{
-    return !operator==(r);
-}
-
 bool
 IceInternal::FixedReference::operator<(const Reference& r) const
 {
@@ -1039,7 +1039,7 @@ IceInternal::RoutableReference::changeAdapterId(const string& newAdapterId) cons
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeLocator(const LocatorPrx& newLocator) const
+IceInternal::RoutableReference::changeLocator(const LocatorPrxPtr& newLocator) const
 {
     LocatorInfoPtr newLocatorInfo = getInstance()->locatorManager()->get(newLocator);
     if(newLocatorInfo == _locatorInfo)
@@ -1052,7 +1052,7 @@ IceInternal::RoutableReference::changeLocator(const LocatorPrx& newLocator) cons
 }
 
 ReferencePtr
-IceInternal::RoutableReference::changeRouter(const RouterPrx& newRouter) const
+IceInternal::RoutableReference::changeRouter(const RouterPrxPtr& newRouter) const
 {
     RouterInfoPtr newRouterInfo = getInstance()->routerManager()->get(newRouter);
     if(newRouterInfo == _routerInfo)
@@ -1180,7 +1180,7 @@ IceInternal::RoutableReference::isWellKnown() const
 }
 
 void
-IceInternal::RoutableReference::streamWrite(BasicStream* s) const
+IceInternal::RoutableReference::streamWrite(OutputStream* s) const
 {
     Reference::streamWrite(s);
 
@@ -1234,8 +1234,7 @@ IceInternal::RoutableReference::toString() const
         // reference parser uses as separators, then we enclose the
         // adapter id string in quotes.
         //
-        string a = nativeToUTF8(_adapterId, getInstance()->getStringConverter());
-        a = IceUtilInternal::escapeString(a, "");
+        string a = escapeString(_adapterId, "", getInstance()->toStringMode());
         if(a.find_first_of(" :@") != string::npos)
         {
             result.append("\"");
@@ -1263,7 +1262,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const
     properties[prefix + ".CollocationOptimized"] = _collocationOptimized ? "1" : "0";
     properties[prefix + ".ConnectionCached"] = _cacheConnection ? "1" : "0";
     properties[prefix + ".PreferSecure"] = _preferSecure ? "1" : "0";
-    properties[prefix + ".EndpointSelection"] = _endpointSelection == Random ? "Random" : "Ordered";
+    properties[prefix + ".EndpointSelection"] = _endpointSelection == ICE_ENUM(EndpointSelectionType, Random) ? "Random" : "Ordered";
     {
         ostringstream s;
         s << _locatorCacheTimeout;
@@ -1276,7 +1275,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const
     }
     if(_routerInfo)
     {
-        PropertyDict routerProperties = _routerInfo->getRouter()->__reference()->toProperty(prefix + ".Router");
+        PropertyDict routerProperties = _routerInfo->getRouter()->_getReference()->toProperty(prefix + ".Router");
         for(PropertyDict::const_iterator p = routerProperties.begin(); p != routerProperties.end(); ++p)
         {
             properties[p->first] = p->second;
@@ -1285,7 +1284,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const
 
     if(_locatorInfo)
     {
-        PropertyDict locatorProperties = _locatorInfo->getLocator()->__reference()->toProperty(prefix + ".Locator");
+        PropertyDict locatorProperties = _locatorInfo->getLocator()->_getReference()->toProperty(prefix + ".Locator");
         for(PropertyDict::const_iterator p = locatorProperties.begin(); p != locatorProperties.end(); ++p)
         {
             properties[p->first] = p->second;
@@ -1351,7 +1350,16 @@ IceInternal::RoutableReference::operator==(const Reference& r) const
     {
         return false;
     }
+#ifdef ICE_CPP11_MAPPING
+    //
+    // TODO: With C++14 we could use the version that receives four iterators and we don't need to explicitly
+    // check the sizes are equal.
+    //
+    if(_endpoints.size() != rhs->_endpoints.size() ||
+       !equal(_endpoints.begin(), _endpoints.end(), rhs->_endpoints.begin(), Ice::TargetCompare<shared_ptr<EndpointI>, std::equal_to>()))
+#else
     if(_endpoints != rhs->_endpoints)
+#endif
     {
         return false;
     }
@@ -1366,12 +1374,6 @@ IceInternal::RoutableReference::operator==(const Reference& r) const
     return true;
 }
 
-bool
-IceInternal::RoutableReference::operator!=(const Reference& r) const
-{
-    return !operator==(r);
-}
-
 bool
 IceInternal::RoutableReference::operator<(const Reference& r) const
 {
@@ -1479,7 +1481,12 @@ IceInternal::RoutableReference::operator<(const Reference& r) const
     {
         return false;
     }
+#ifdef ICE_CPP11_MAPPING
+    if(lexicographical_compare(_endpoints.begin(), _endpoints.end(), rhs->_endpoints.begin(), rhs->_endpoints.end(),
+                               Ice::TargetCompare<shared_ptr<EndpointI>, std::less>()))
+#else
     if(_endpoints < rhs->_endpoints)
+#endif
     {
         return true;
     }
@@ -1505,7 +1512,7 @@ IceInternal::RoutableReference::clone() const
 }
 
 RequestHandlerPtr
-IceInternal::RoutableReference::getRequestHandler(const Ice::ObjectPrx& proxy) const
+IceInternal::RoutableReference::getRequestHandler(const Ice::ObjectPrxPtr& proxy) const
 {
     return getInstance()->requestHandlerFactory()->getRequestHandler(const_cast<RoutableReference*>(this), proxy);
 }
@@ -1604,10 +1611,10 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
                     {
                         TraceLevelsPtr traceLvls = _reference->getInstance()->traceLevels();
                         if(traceLvls->retry >= 2)
-                            {
+                        {
                             Trace out(_reference->getInstance()->initializationData().logger, traceLvls->retryCat);
                             out << "connection to cached endpoints failed\n"
-                                << "removing endpoints from cache and trying one more time\n" << ex;
+                                << "removing endpoints from cache and trying again\n" << ex;
                         }
                         _reference->getConnectionNoRouterInfo(_callback); // Retry.
                         return;
@@ -1628,7 +1635,6 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
             const bool _cached;
         };
 
-
         virtual void
         setEndpoints(const vector<EndpointIPtr>& endpoints, bool cached)
         {
@@ -1640,7 +1646,7 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
 
             vector<EndpointIPtr> endpts = endpoints;
             _reference->applyOverrides(endpts);
-            _reference->createConnection(endpts, new Callback2(_reference, _callback, cached));
+            _reference->createConnection(endpts, ICE_MAKE_SHARED(Callback2, _reference, _callback, cached));
         }
 
         virtual void
@@ -1669,7 +1675,7 @@ IceInternal::RoutableReference::getConnectionNoRouterInfo(const GetConnectionCal
     if(_locatorInfo)
     {
         RoutableReference* self = const_cast<RoutableReference*>(this);
-        _locatorInfo->getEndpointsWithCallback(self, _locatorCacheTimeout, new Callback(self, callback));
+        _locatorInfo->getEndpoints(self, _locatorCacheTimeout, new Callback(self, callback));
     }
     else
     {
@@ -1761,14 +1767,14 @@ IceInternal::RoutableReference::createConnection(const vector<EndpointIPtr>& all
             virtual void
             setException(const Ice::LocalException& ex)
             {
-                if(!_exception.get())
+                if(!_exception)
                 {
-                    _exception.reset(ex.ice_clone());
+                    ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone());
                 }
 
                 if(++_i == _endpoints.size())
                 {
-                    _callback->setException(*_exception.get());
+                    _callback->setException(*_exception);
                     return;
                 }
 
@@ -1795,7 +1801,7 @@ IceInternal::RoutableReference::createConnection(const vector<EndpointIPtr>& all
             const vector<EndpointIPtr> _endpoints;
             const GetConnectionCallbackPtr _callback;
             size_t _i;
-            IceUtil::UniquePtr<Ice::LocalException> _exception;
+            IceInternal::UniquePtr<Ice::LocalException> _exception;
         };
 
         //
@@ -1909,13 +1915,13 @@ IceInternal::RoutableReference::filterEndpoints(const vector<EndpointIPtr>& allE
     //
     switch(getEndpointSelection())
     {
-        case Random:
+        case ICE_ENUM(EndpointSelectionType, Random):
         {
             RandomNumberGenerator rng;
             random_shuffle(endpoints.begin(), endpoints.end(), rng);
             break;
         }
-        case Ordered:
+        case ICE_ENUM(EndpointSelectionType, Ordered):
         {
             // Nothing to do.
             break;