zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,76 +1,58 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_REFERENCE_FACTORY_H
 #define ICE_REFERENCE_FACTORY_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/ReferenceFactoryF.h>
-#include <Ice/Reference.h> // For Reference::Mode
-#include <Ice/ConnectionIF.h>
-#include <Ice/BuiltinSequences.h>
+#include "Ice/BuiltinSequences.h"
+#include "Ice/ConnectionIF.h"
+#include "Reference.h" // For Reference::Mode
+#include "ReferenceFactoryF.h"
 
 namespace IceInternal
 {
-
-class ReferenceFactory : public ::IceUtil::Shared
-{
-public:
-
-    //
-    // Make a polymorphic copy of a reference.
-    //
-    ReferencePtr copy(const Reference* r) const;
-
-    //
-    // Create a direct reference.
-    //
-    ReferencePtr create(const ::Ice::Identity&, const ::std::string&, const ReferencePtr&,
-                        const ::std::vector<EndpointIPtr>&);
-
-    //
-    // Create an indirect reference.
-    //
-    ReferencePtr create(const ::Ice::Identity&, const ::std::string&, const ReferencePtr&, const std::string&);
-
-    //
-    // Create a fixed reference.
-    //
-    ReferencePtr create(const ::Ice::Identity&, const Ice::ConnectionIPtr&);
-
-    //
-    // Create a reference from a string.
-    //
-    ReferencePtr create(const ::std::string&, const std::string&);
-
-    //
-    // Create a reference by unmarshaling it from a stream.
-    //
-    ReferencePtr create(const ::Ice::Identity&, Ice::InputStream*);
-
-    ReferenceFactoryPtr setDefaultRouter(const ::Ice::RouterPrxPtr&);
-    ::Ice::RouterPrxPtr getDefaultRouter() const;
-
-    ReferenceFactoryPtr setDefaultLocator(const ::Ice::LocatorPrxPtr&);
-    ::Ice::LocatorPrxPtr getDefaultLocator() const;
-
-private:
-
-    ReferenceFactory(const InstancePtr&, const ::Ice::CommunicatorPtr&);
-    friend class Instance;
-
-    void checkForUnknownProperties(const std::string&);
-    RoutableReferencePtr create(const ::Ice::Identity&, const ::std::string&, Reference::Mode, bool,
-                                const Ice::ProtocolVersion&, const Ice::EncodingVersion&,
-                                const std::vector<EndpointIPtr>&, const std::string&, const std::string&);
-
-    const InstancePtr _instance;
-    const ::Ice::CommunicatorPtr _communicator;
-    ::Ice::RouterPrxPtr _defaultRouter;
-    ::Ice::LocatorPrxPtr _defaultLocator;
-};
-
+    class ReferenceFactory : public std::enable_shared_from_this<ReferenceFactory>
+    {
+    public:
+        ReferenceFactory(InstancePtr, Ice::CommunicatorPtr);
+
+        // Create a direct reference.
+        ReferencePtr
+        create(Ice::Identity ident, std::string facet, const ReferencePtr& tmpl, std::vector<EndpointIPtr> endpoints);
+
+        // Create an indirect reference.
+        ReferencePtr create(Ice::Identity ident, std::string facet, const ReferencePtr& tmpl, std::string adapterId);
+
+        // Create a fixed reference.
+        ReferencePtr create(Ice::Identity ident, Ice::ConnectionIPtr connection);
+
+        // Create a reference from a string.
+        ReferencePtr create(std::string_view proxyString, const std::string& prefix);
+
+        // Create a reference by unmarshaling it from a stream.
+        ReferencePtr create(Ice::Identity ident, Ice::InputStream*);
+
+        ReferenceFactoryPtr setDefaultRouter(std::optional<Ice::RouterPrx>);
+        [[nodiscard]] std::optional<Ice::RouterPrx> getDefaultRouter() const;
+
+        ReferenceFactoryPtr setDefaultLocator(std::optional<Ice::LocatorPrx>);
+        [[nodiscard]] std::optional<Ice::LocatorPrx> getDefaultLocator() const;
+
+    private:
+        RoutableReferencePtr create(
+            Ice::Identity ident,
+            std::string facet,
+            Reference::Mode mode,
+            Ice::ProtocolVersion protocol,
+            Ice::EncodingVersion encoding,
+            std::vector<EndpointIPtr> endpoints,
+            std::string adapterId,
+            const std::string& propertyPrefix);
+
+        const InstancePtr _instance;
+        const Ice::CommunicatorPtr _communicator;
+        std::optional<Ice::RouterPrx> _defaultRouter;
+        std::optional<Ice::LocatorPrx> _defaultLocator;
+    };
 }
 
 #endif

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

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

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

@@ -1,37 +1,28 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/RequestHandler.h>
-#include <Ice/Reference.h>
+#include "RequestHandler.h"
+#include "Reference.h"
 
 using namespace std;
+using namespace Ice;
 using namespace IceInternal;
 
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(RequestHandler* p) { return p; }
-IceUtil::Shared* IceInternal::upCast(CancellationHandler* p) { return p; }
-#endif
+RetryException::RetryException(exception_ptr ex) { _ex = ex; }
 
-RetryException::RetryException(const Ice::LocalException& ex)
-{
-    ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.ice_clone());
-}
+RetryException::RetryException(const RetryException& ex) { _ex = ex.get(); }
 
-RetryException::RetryException(const RetryException& ex)
-{
-    ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.get()->ice_clone());
-}
-
-const Ice::LocalException*
+exception_ptr
 RetryException::get() const
 {
-    assert(_ex.get());
-    return _ex.get();
+    return _ex;
 }
 
-RequestHandler::RequestHandler(const ReferencePtr& reference) :
-    _reference(reference),
-    _response(reference->getMode() == Reference::ModeTwoway)
+CancellationHandler::~CancellationHandler() = default; // avoid weak vtable
+
+RequestHandler::RequestHandler(const ReferencePtr& reference)
+    : _reference(reference),
+      _response(reference->getMode() == Reference::ModeTwoway)
 {
 }
+
+RequestHandler::~RequestHandler() = default; // avoid weak vtable

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

@@ -1,78 +1,53 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_REQUEST_HANDLER_H
 #define ICE_REQUEST_HANDLER_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/UniquePtr.h>
-
-#include <Ice/RequestHandlerF.h>
-#include <Ice/ReferenceF.h>
-#include <Ice/OutgoingAsyncF.h>
-#include <Ice/ProxyF.h>
-#include <Ice/ConnectionIF.h>
-
-namespace Ice
-{
-
-class LocalException;
-
-}
+#include "Ice/ConnectionIF.h"
+#include "Ice/OutgoingAsync.h"
+#include "Ice/ReferenceF.h"
+#include "Ice/RequestHandlerF.h"
 
 namespace IceInternal
 {
-
-//
-// An exception wrapper, which is used to notify that the request
-// handler should be cleared and the invocation retried.
-//
-class RetryException
-{
-public:
-
-    RetryException(const Ice::LocalException&);
-    RetryException(const RetryException&);
-
-    const Ice::LocalException* get() const;
-
-private:
-
-    IceInternal::UniquePtr<Ice::LocalException> _ex;
-};
-
-class CancellationHandler
-#ifndef ICE_CPP11_MAPPING
-    : public virtual IceUtil::Shared
-#endif
-{
-public:
-
-    virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&) = 0;
-};
-
-class RequestHandler : public CancellationHandler
-{
-public:
-
-    RequestHandler(const ReferencePtr&);
-
-    virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&) = 0;
-
-    virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) = 0;
-
-    const ReferencePtr& getReference() const { return _reference; } // Inlined for performances.
-
-    virtual Ice::ConnectionIPtr getConnection() = 0;
-    virtual Ice::ConnectionIPtr waitForConnection() = 0;
-
-protected:
-
-    const ReferencePtr _reference;
-    const bool _response;
-};
-
+    //
+    // An exception wrapper, which is used to notify that the request
+    // handler should be cleared and the invocation retried.
+    //
+    class RetryException
+    {
+    public:
+        RetryException(std::exception_ptr);
+        RetryException(const RetryException&);
+
+        [[nodiscard]] std::exception_ptr get() const;
+
+    private:
+        std::exception_ptr _ex;
+    };
+
+    class CancellationHandler
+    {
+    public:
+        virtual ~CancellationHandler();
+
+        virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) = 0;
+    };
+
+    class RequestHandler : public CancellationHandler
+    {
+    public:
+        RequestHandler(const ReferencePtr&);
+        ~RequestHandler() override;
+
+        virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) = 0;
+
+        virtual Ice::ConnectionIPtr getConnection() = 0;
+
+    protected:
+        const ReferencePtr _reference;
+        const bool _response;
+    };
 }
 
 #endif

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

@@ -0,0 +1,76 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "RequestHandlerCache.h"
+#include "ConnectionI.h"
+#include "Reference.h"
+#include "RequestHandler.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+RequestHandlerCache::RequestHandlerCache(const ReferencePtr& reference)
+    : _reference(reference),
+      _cacheConnection(reference->getCacheConnection())
+{
+}
+
+IceInternal::RequestHandlerPtr
+RequestHandlerCache::getRequestHandler()
+{
+    if (_cacheConnection)
+    {
+        lock_guard<mutex> lock(_mutex);
+        if (_cachedRequestHandler)
+        {
+            return _cachedRequestHandler;
+        }
+    }
+
+    auto handler = _reference->getRequestHandler();
+    if (_cacheConnection)
+    {
+        lock_guard<mutex> lock(_mutex);
+        if (!_cachedRequestHandler)
+        {
+            _cachedRequestHandler = handler;
+        }
+        // else discard handler
+        return _cachedRequestHandler;
+    }
+    else
+    {
+        return handler;
+    }
+}
+
+ConnectionPtr
+RequestHandlerCache::getCachedConnection()
+{
+    if (_cacheConnection)
+    {
+        RequestHandlerPtr handler;
+        {
+            lock_guard<mutex> lock(_mutex);
+            handler = _cachedRequestHandler;
+        }
+        if (handler)
+        {
+            return handler->getConnection();
+        }
+    }
+    return nullptr;
+}
+
+void
+RequestHandlerCache::clearCachedRequestHandler(const RequestHandlerPtr& handler)
+{
+    if (_cacheConnection)
+    {
+        lock_guard<mutex> lock(_mutex);
+        if (handler == _cachedRequestHandler)
+        {
+            _cachedRequestHandler = nullptr;
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_REQUEST_HANDLER_CACHE_H
+#define ICE_REQUEST_HANDLER_CACHE_H
+
+#include "Ice/ConnectionF.h"
+#include "RequestHandler.h"
+#include <mutex>
+
+namespace IceInternal
+{
+    // Represents a holder/cache for a request handler. It's tied to a single Reference, and can be shared by multiple
+    // proxies (all with the same Reference).
+    class RequestHandlerCache final
+    {
+    public:
+        RequestHandlerCache(const ReferencePtr&);
+
+        RequestHandlerPtr getRequestHandler();
+
+        Ice::ConnectionPtr getCachedConnection();
+
+        void clearCachedRequestHandler(const RequestHandlerPtr& handler);
+
+    private:
+        const ReferencePtr _reference;
+        const bool _cacheConnection;
+        std::mutex _mutex;                       // protects _cachedRequestHandler
+        RequestHandlerPtr _cachedRequestHandler; // set only when _cacheConnection is true.
+    };
+}
+
+#endif

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

@@ -0,0 +1,27 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_RESOURCE_CONFIG_H
+#define ICE_RESOURCE_CONFIG_H
+
+#include "winver.h"
+
+#define ICE_VERSION 3, 8, 1, 0
+#define ICE_STRING_VERSION "3.8.1\0"
+#define ICE_SO_VERSION "38\0"
+#define ICE_COMPANY_NAME "ZeroC, Inc.\0"
+#define ICE_COPYRIGHT "\251 ZeroC, Inc.\0"
+#define ICE_PRODUCT_NAME "Ice\0"
+
+#if defined(_DEBUG)
+#    define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION "D"
+#else
+#    define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION ""
+#endif
+
+#ifndef DEBUG
+#    define VER_DEBUG 0
+#else
+#    define VER_DEBUG VS_FF_DEBUG
+#endif
+
+#endif

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

@@ -1,26 +1,22 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/RetryQueue.h>
-#include <Ice/OutgoingAsync.h>
-#include <Ice/LocalException.h>
-#include <Ice/Instance.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/LoggerUtil.h>
+#include "RetryQueue.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/OutgoingAsync.h"
+#include "Instance.h"
+#include "TraceLevels.h"
+
+#include <stdexcept>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(RetryQueue* p) { return p; }
-
-IceInternal::RetryTask::RetryTask(const InstancePtr& instance,
-                                  const RetryQueuePtr& queue,
-                                  const ProxyOutgoingAsyncBasePtr& outAsync) :
-    _instance(instance),
-    _queue(queue),
-    _outAsync(outAsync)
+IceInternal::RetryTask::RetryTask(InstancePtr instance, RetryQueuePtr queue, ProxyOutgoingAsyncBasePtr outAsync)
+    : _instance(std::move(instance)),
+      _queue(std::move(queue)),
+      _outAsync(std::move(outAsync))
 {
 }
 
@@ -35,20 +31,27 @@ IceInternal::RetryTask::runTimerTask()
     // (we still need the client thread pool at this point to call
     // exception callbacks with CommunicatorDestroyedException).
     //
-    _queue->remove(ICE_SHARED_FROM_THIS);
+    _queue->remove(shared_from_this());
 }
 
 void
-IceInternal::RetryTask::asyncRequestCanceled(const OutgoingAsyncBasePtr& /*outAsync*/, const Ice::LocalException& ex)
+IceInternal::RetryTask::asyncRequestCanceled(const OutgoingAsyncBasePtr& /*outAsync*/, exception_ptr ex)
 {
-    if(_queue->cancel(ICE_SHARED_FROM_THIS))
+    if (_queue->cancel(shared_from_this()))
     {
-        if(_instance->traceLevels()->retry >= 1)
+        if (_instance->traceLevels()->retry >= 1)
         {
-            Trace out(_instance->initializationData().logger, _instance->traceLevels()->retryCat);
-            out << "operation retry canceled\n" << ex;
+            try
+            {
+                rethrow_exception(ex);
+            }
+            catch (const std::exception& e)
+            {
+                Trace out(_instance->initializationData().logger, _instance->traceLevels()->retryCat);
+                out << "operation retry canceled\n" << e;
+            }
         }
-        if(_outAsync->exception(ex))
+        if (_outAsync->exception(ex))
         {
             _outAsync->invokeExceptionAsync();
         }
@@ -60,39 +63,31 @@ IceInternal::RetryTask::destroy()
 {
     try
     {
-        _outAsync->abort(CommunicatorDestroyedException(__FILE__, __LINE__));
+        _outAsync->abort(make_exception_ptr(CommunicatorDestroyedException(__FILE__, __LINE__)));
     }
-    catch(const CommunicatorDestroyedException&)
+    catch (const CommunicatorDestroyedException&)
     {
         // Abort can throw if there's no callback, ignore.
     }
 }
 
-bool
-IceInternal::RetryTask::operator<(const RetryTask& rhs) const
-{
-    return this < &rhs;
-}
-
-IceInternal::RetryQueue::RetryQueue(const InstancePtr& instance) : _instance(instance)
-{
-}
+IceInternal::RetryQueue::RetryQueue(InstancePtr instance) : _instance(std::move(instance)) {}
 
 void
 IceInternal::RetryQueue::add(const ProxyOutgoingAsyncBasePtr& out, int interval)
 {
-    Lock sync(*this);
-    if(!_instance)
+    lock_guard<mutex> lock(_mutex);
+    if (!_instance)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
-    RetryTaskPtr task = ICE_MAKE_SHARED(RetryTask, _instance, this, out);
+    RetryTaskPtr task = make_shared<RetryTask>(_instance, shared_from_this(), out);
     out->cancelable(task); // This will throw if the request is canceled.
     try
     {
-        _instance->timer()->schedule(task, IceUtil::Time::milliSeconds(interval));
+        _instance->timer()->schedule(task, chrono::milliseconds(interval));
     }
-    catch(const IceUtil::IllegalArgumentException&) // Expected if the communicator destroyed the timer.
+    catch (const invalid_argument&) // Expected if the communicator destroyed the timer.
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -102,13 +97,13 @@ IceInternal::RetryQueue::add(const ProxyOutgoingAsyncBasePtr& out, int interval)
 void
 IceInternal::RetryQueue::destroy()
 {
-    Lock sync(*this);
+    unique_lock<mutex> lock(_mutex);
     assert(_instance);
 
-    set<RetryTaskPtr>::iterator p = _requests.begin();
-    while(p != _requests.end())
+    auto p = _requests.begin();
+    while (p != _requests.end())
     {
-        if(_instance->timer()->cancel(*p))
+        if (_instance->timer()->cancel(*p))
         {
             (*p)->destroy();
             _requests.erase(p++);
@@ -119,38 +114,37 @@ IceInternal::RetryQueue::destroy()
         }
     }
 
-    _instance = 0;
-    while(!_requests.empty())
-    {
-        wait();
-    }
+    _instance = nullptr;
+    _conditionVariable.wait(lock, [this] { return _requests.empty(); });
 }
 
 void
 IceInternal::RetryQueue::remove(const RetryTaskPtr& task)
 {
-    Lock sync(*this);
+    lock_guard<mutex> lock(_mutex);
     assert(_requests.find(task) != _requests.end());
     _requests.erase(task);
-    if(!_instance && _requests.empty())
+    if (!_instance && _requests.empty())
     {
-        notify(); // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
+        // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
+        _conditionVariable.notify_one();
     }
 }
 
 bool
 IceInternal::RetryQueue::cancel(const RetryTaskPtr& task)
 {
-    Lock sync(*this);
-    if(_requests.erase(task) > 0)
+    lock_guard<mutex> lock(_mutex);
+    if (_requests.erase(task) > 0)
     {
-        if(_instance)
+        if (_instance)
         {
             return _instance->timer()->cancel(task);
         }
-        else if(_requests.empty())
+        else if (_requests.empty())
         {
-            notify(); // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
+            // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
+            _conditionVariable.notify_one();
         }
     }
     return false;