zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,264 +1,264 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_CONNECTION_FACTORY_H
 #define ICE_CONNECTION_FACTORY_H
 
-#include <IceUtil/Mutex.h>
-#include <IceUtil/Monitor.h>
-#include <Ice/CommunicatorF.h>
-#include <Ice/ConnectionFactoryF.h>
-#include <Ice/ConnectionI.h>
-#include <Ice/InstanceF.h>
-#include <Ice/ObjectAdapterF.h>
-#include <Ice/EndpointIF.h>
-#include <Ice/Endpoint.h>
-#include <Ice/ConnectorF.h>
-#include <Ice/AcceptorF.h>
-#include <Ice/TransceiverF.h>
-#include <Ice/RouterInfoF.h>
-#include <Ice/EventHandler.h>
-#include <Ice/EndpointI.h>
-#include <Ice/InstrumentationF.h>
-#include <Ice/ACMF.h>
-#include <Ice/Comparable.h>
-
+#include "AcceptorF.h"
+#include "ConnectionFactoryF.h"
+#include "ConnectionI.h"
+#include "ConnectorF.h"
+#include "EndpointI.h"
+#include "EndpointIF.h"
+#include "EventHandler.h"
+#include "Ice/CommunicatorF.h"
+#include "Ice/Endpoint.h"
+#include "Ice/InstanceF.h"
+#include "Ice/Instrumentation.h"
+#include "Ice/ObjectAdapterF.h"
+#include "RouterInfoF.h"
+#include "TargetCompare.h"
+#include "TransceiverF.h"
+
+#include <condition_variable>
 #include <list>
+#include <mutex>
 #include <set>
 
 namespace Ice
 {
-
-class LocalException;
-class ObjectAdapterI;
-ICE_DEFINE_PTR(ObjectAdapterIPtr, ObjectAdapterI);
-
+    class ObjectAdapterI;
 }
 
 namespace IceInternal
 {
+    class ThreadPoolCurrent;
 
-class OutgoingConnectionFactory : public virtual IceUtil::Shared, public IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
+    class CommunicatorFlushBatchAsync;
+    using CommunicatorFlushBatchAsyncPtr = std::shared_ptr<CommunicatorFlushBatchAsync>;
+
+    template<typename T> class ThreadPoolMessage;
 
-    class CreateConnectionCallback : public virtual IceUtil::Shared
+    class OutgoingConnectionFactory final : public std::enable_shared_from_this<OutgoingConnectionFactory>
     {
     public:
+        void destroy();
 
-        virtual void setConnection(const Ice::ConnectionIPtr&, bool) = 0;
-        virtual void setException(const Ice::LocalException&) = 0;
-    };
-    typedef IceUtil::Handle<CreateConnectionCallback> CreateConnectionCallbackPtr;
+        void updateConnectionObservers();
 
-    void destroy();
+        void waitUntilFinished();
 
-    void updateConnectionObservers();
+        void createAsync(
+            std::vector<EndpointIPtr>,
+            bool,
+            std::function<void(Ice::ConnectionIPtr, bool)>,
+            std::function<void(std::exception_ptr)>);
 
-    void waitUntilFinished();
+        void setRouterInfo(const RouterInfoPtr&);
+        void removeAdapter(const Ice::ObjectAdapterPtr&);
+        void flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr&, Ice::CompressBatch);
 
-    void create(const std::vector<EndpointIPtr>&, bool, Ice::EndpointSelectionType, const CreateConnectionCallbackPtr&);
-    void setRouterInfo(const RouterInfoPtr&);
-    void removeAdapter(const Ice::ObjectAdapterPtr&);
-    void flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr&, Ice::CompressBatch);
+        void removeConnection(const Ice::ConnectionIPtr&) noexcept;
 
-    OutgoingConnectionFactory(const Ice::CommunicatorPtr&, const InstancePtr&);
-    virtual ~OutgoingConnectionFactory();
-    friend class Instance;
+        void setDefaultObjectAdapter(Ice::ObjectAdapterPtr adapter) noexcept;
+        [[nodiscard]] Ice::ObjectAdapterPtr getDefaultObjectAdapter() const noexcept;
 
-private:
+        OutgoingConnectionFactory(Ice::CommunicatorPtr, const InstancePtr&);
+        ~OutgoingConnectionFactory();
+        friend class Instance;
 
-    struct ConnectorInfo
-    {
-        ConnectorInfo(const ConnectorPtr& c, const EndpointIPtr& e) : connector(c), endpoint(e)
+    private:
+        struct ConnectorInfo
         {
-        }
-
-        bool operator==(const ConnectorInfo& other) const;
-
-        ConnectorPtr connector;
-        EndpointIPtr endpoint;
-    };
-
-    class ConnectCallback : public Ice::ConnectionI::StartCallback,
-                            public IceInternal::EndpointI_connectors
-#ifdef ICE_CPP11_MAPPING
-                          , public std::enable_shared_from_this<ConnectCallback>
-#endif
-
-    {
-    public:
+            ConnectorInfo(ConnectorPtr c, EndpointIPtr e) : connector(std::move(c)), endpoint(std::move(e)) {}
 
-        ConnectCallback(const InstancePtr&, const OutgoingConnectionFactoryPtr&, const std::vector<EndpointIPtr>&, bool,
-                        const CreateConnectionCallbackPtr&, Ice::EndpointSelectionType);
+            bool operator==(const ConnectorInfo& other) const;
 
-        virtual void connectionStartCompleted(const Ice::ConnectionIPtr&);
-        virtual void connectionStartFailed(const Ice::ConnectionIPtr&, const Ice::LocalException&);
+            ConnectorPtr connector;
+            EndpointIPtr endpoint;
+        };
 
-        virtual void connectors(const std::vector<ConnectorPtr>&);
-        virtual void exception(const Ice::LocalException&);
-
-        void getConnectors();
-        void nextEndpoint();
-
-        void getConnection();
-        void nextConnector();
-
-        void setConnection(const Ice::ConnectionIPtr&, bool);
-        void setException(const Ice::LocalException&);
-
-        bool hasConnector(const ConnectorInfo&);
-        bool removeConnectors(const std::vector<ConnectorInfo>&);
-        void removeFromPending();
+        class ConnectCallback final : public std::enable_shared_from_this<ConnectCallback>
+        {
+        public:
+            ConnectCallback(
+                InstancePtr,
+                OutgoingConnectionFactoryPtr,
+                std::vector<EndpointIPtr>,
+                bool,
+                std::function<void(Ice::ConnectionIPtr, bool)>,
+                std::function<void(std::exception_ptr)>);
+
+            void connectionStartCompleted(const Ice::ConnectionIPtr&);
+            void connectionStartFailed(const Ice::ConnectionIPtr&, std::exception_ptr);
+
+            void connectors(const std::vector<ConnectorPtr>&);
+            void exception(std::exception_ptr);
+
+            void getConnectors();
+            void nextEndpoint();
+
+            void getConnection();
+            void nextConnector();
+
+            void setConnection(const Ice::ConnectionIPtr&, bool);
+            void setException(std::exception_ptr);
+
+            bool hasConnector(const ConnectorInfo&);
+            bool removeConnectors(const std::vector<ConnectorInfo>&);
+            void removeFromPending();
+
+        private:
+            bool connectionStartFailedImpl(std::exception_ptr);
+
+            const InstancePtr _instance;
+            const OutgoingConnectionFactoryPtr _factory;
+            const std::vector<EndpointIPtr> _endpoints;
+            const bool _hasMore;
+            const std::function<void(Ice::ConnectionIPtr, bool)> _createConnectionResponse;
+            const std::function<void(std::exception_ptr)> _createConnectionException;
+            Ice::Instrumentation::ObserverPtr _observer;
+            std::vector<EndpointIPtr>::const_iterator _endpointsIter;
+            std::vector<ConnectorInfo> _connectors;
+            std::vector<ConnectorInfo>::const_iterator _iter;
+        };
+        using ConnectCallbackPtr = std::shared_ptr<ConnectCallback>;
+        friend class ConnectCallback;
+
+        Ice::ConnectionIPtr findConnection(const std::vector<EndpointIPtr>&, bool&);
+        void incPendingConnectCount();
+        void decPendingConnectCount();
+        Ice::ConnectionIPtr getConnection(const std::vector<ConnectorInfo>&, const ConnectCallbackPtr&, bool&);
+        void finishGetConnection(
+            const std::vector<ConnectorInfo>&,
+            const ConnectorInfo&,
+            const Ice::ConnectionIPtr&,
+            const ConnectCallbackPtr&);
+        void finishGetConnection(const std::vector<ConnectorInfo>&, std::exception_ptr, const ConnectCallbackPtr&);
+
+        bool addToPending(const ConnectCallbackPtr&, const std::vector<ConnectorInfo>&);
+        void removeFromPending(const ConnectCallbackPtr&, const std::vector<ConnectorInfo>&);
+
+        Ice::ConnectionIPtr findConnection(const std::vector<ConnectorInfo>&, bool&);
+        Ice::ConnectionIPtr createConnection(const TransceiverPtr&, const ConnectorInfo&);
+
+        void handleException(std::exception_ptr, bool);
+        void handleConnectionException(std::exception_ptr, bool);
+
+        Ice::CommunicatorPtr _communicator;
+        const InstancePtr _instance;
+        const Ice::ConnectionOptions _connectionOptions;
 
-        bool operator<(const ConnectCallback&) const;
+        bool _destroyed{false};
 
-    private:
+        using ConnectCallbackSet = std::set<ConnectCallbackPtr>;
 
-        bool connectionStartFailedImpl(const Ice::LocalException&);
+        std::multimap<ConnectorPtr, Ice::ConnectionIPtr, Ice::TargetCompare<ConnectorPtr, std::less>> _connections;
+        std::map<ConnectorPtr, ConnectCallbackSet, Ice::TargetCompare<ConnectorPtr, std::less>> _pending;
 
-        const InstancePtr _instance;
-        const OutgoingConnectionFactoryPtr _factory;
-        const std::vector<EndpointIPtr> _endpoints;
-        const bool _hasMore;
-        const CreateConnectionCallbackPtr _callback;
-        const Ice::EndpointSelectionType _selType;
-        Ice::Instrumentation::ObserverPtr _observer;
-        std::vector<EndpointIPtr>::const_iterator _endpointsIter;
-        std::vector<ConnectorInfo> _connectors;
-        std::vector<ConnectorInfo>::const_iterator _iter;
+        std::multimap<EndpointIPtr, Ice::ConnectionIPtr, Ice::TargetCompare<EndpointIPtr, std::less>>
+            _connectionsByEndpoint;
+        int _pendingConnectCount{0};
+        Ice::ObjectAdapterIPtr _defaultObjectAdapter;
+        mutable std::mutex _mutex;
+        std::condition_variable _conditionVariable;
     };
-    ICE_DEFINE_PTR(ConnectCallbackPtr, ConnectCallback);
-    friend class ConnectCallback;
-
-    std::vector<EndpointIPtr> applyOverrides(const std::vector<EndpointIPtr>&);
-    Ice::ConnectionIPtr findConnection(const std::vector<EndpointIPtr>&, bool&);
-    void incPendingConnectCount();
-    void decPendingConnectCount();
-    Ice::ConnectionIPtr getConnection(const std::vector<ConnectorInfo>&, const ConnectCallbackPtr&, bool&);
-    void finishGetConnection(const std::vector<ConnectorInfo>&, const ConnectorInfo&, const Ice::ConnectionIPtr&,
-                             const ConnectCallbackPtr&);
-    void finishGetConnection(const std::vector<ConnectorInfo>&, const Ice::LocalException&, const ConnectCallbackPtr&);
-
-    bool addToPending(const ConnectCallbackPtr&, const std::vector<ConnectorInfo>&);
-    void removeFromPending(const ConnectCallbackPtr&, const std::vector<ConnectorInfo>&);
-
-    Ice::ConnectionIPtr findConnection(const std::vector<ConnectorInfo>&, bool&);
-    Ice::ConnectionIPtr createConnection(const TransceiverPtr&, const ConnectorInfo&);
-
-    void handleException(const Ice::LocalException&, bool);
-    void handleConnectionException(const Ice::LocalException&, bool);
-
-    Ice::CommunicatorPtr _communicator;
-    const InstancePtr _instance;
-    const FactoryACMMonitorPtr _monitor;
-    bool _destroyed;
-
-    std::multimap<ConnectorPtr, Ice::ConnectionIPtr> _connections;
-    std::map<ConnectorPtr, std::set<ConnectCallbackPtr> > _pending;
-
-#ifdef ICE_CPP11_MAPPING
-    std::multimap<EndpointIPtr, Ice::ConnectionIPtr, Ice::TargetCompare<EndpointIPtr, std::less>> _connectionsByEndpoint;
-#else
-    std::multimap<EndpointIPtr, Ice::ConnectionIPtr> _connectionsByEndpoint;
-#endif
-    int _pendingConnectCount;
-};
-
-class IncomingConnectionFactory : public EventHandler,
-                                  public Ice::ConnectionI::StartCallback,
-                                  public IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
 
-    void activate();
-    void hold();
-    void destroy();
+    class IncomingConnectionFactory final : public EventHandler
+    {
+    public:
+        IncomingConnectionFactory(const InstancePtr&, const EndpointIPtr&, const std::shared_ptr<Ice::ObjectAdapterI>&);
+        void activate();
+        void hold();
+        void destroy();
+
+#if defined(__APPLE__) && TARGET_OS_IPHONE != 0
+        // Used on iOS to stop/start the acceptor when the app enters background/foreground mode.
+        void startAcceptor();
+        void stopAcceptor();
+#endif
 
-    void startAcceptor();
-    void stopAcceptor();
+        void updateConnectionObservers();
 
-    void updateConnectionObservers();
+        void waitUntilHolding() const;
+        void waitUntilFinished();
 
-    void waitUntilHolding() const;
-    void waitUntilFinished();
+        [[nodiscard]] EndpointIPtr endpoint() const;
+        [[nodiscard]] std::list<Ice::ConnectionIPtr> connections() const;
+        void removeConnection(const Ice::ConnectionIPtr&) noexcept;
 
-    bool isLocal(const EndpointIPtr&) const;
-    EndpointIPtr endpoint() const;
-    std::list<Ice::ConnectionIPtr> connections() const;
-    void flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr&, Ice::CompressBatch);
+        void flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr&, Ice::CompressBatch);
 
-    //
-    // Operations from EventHandler
-    //
+        //
+        // Operations from EventHandler
+        //
 
 #if defined(ICE_USE_IOCP)
-    virtual bool startAsync(SocketOperation);
-    virtual bool finishAsync(SocketOperation);
+        bool startAsync(SocketOperation) final;
+        bool finishAsync(SocketOperation) final;
 #endif
 
-    virtual void message(ThreadPoolCurrent&);
-    virtual void finished(ThreadPoolCurrent&, bool);
+        void message(ThreadPoolCurrent&) override;
+        void finished(ThreadPoolCurrent&, bool) override;
 #if TARGET_OS_IPHONE != 0
-    void finish();
+        void finish();
 #endif
-    virtual std::string toString() const;
-    virtual NativeInfoPtr getNativeInfo();
+        [[nodiscard]] std::string toString() const override;
+        NativeInfoPtr getNativeInfo() override;
 
-    virtual void connectionStartCompleted(const Ice::ConnectionIPtr&);
-    virtual void connectionStartFailed(const Ice::ConnectionIPtr&, const Ice::LocalException&);
+        void connectionStartCompleted(const Ice::ConnectionIPtr&);
+        void connectionStartFailed(const Ice::ConnectionIPtr&, std::exception_ptr);
+        void initialize();
+        ~IncomingConnectionFactory() override;
 
-    IncomingConnectionFactory(const InstancePtr&, const EndpointIPtr&, const EndpointIPtr&,
-                              const Ice::ObjectAdapterIPtr&);
-    void initialize();
-    virtual ~IncomingConnectionFactory();
-
-#ifdef ICE_CPP11_MAPPING
-    std::shared_ptr<IncomingConnectionFactory> shared_from_this()
-    {
-        return std::static_pointer_cast<IncomingConnectionFactory>(EventHandler::shared_from_this());
-    }
-#endif
+        std::shared_ptr<IncomingConnectionFactory> shared_from_this()
+        {
+            return std::static_pointer_cast<IncomingConnectionFactory>(EventHandler::shared_from_this());
+        }
 
-private:
+    private:
+        friend class Ice::ObjectAdapterI;
 
-    friend class Ice::ObjectAdapterI;
+        enum State
+        {
+            StateActive,
+            StateHolding,
+            StateClosed,
+            StateFinished
+        };
 
-    enum State
-    {
-        StateActive,
-        StateHolding,
-        StateClosed,
-        StateFinished
-    };
+        void setState(State);
 
-    void setState(State);
+        void createAcceptor();
+        void closeAcceptor();
 
-    void createAcceptor();
-    void closeAcceptor();
+        const InstancePtr _instance;
+        const Ice::ConnectionOptions _connectionOptions;
 
-    const InstancePtr _instance;
-    const FactoryACMMonitorPtr _monitor;
+        const int _maxConnections;
 
-    AcceptorPtr _acceptor;
-    const TransceiverPtr _transceiver;
-    EndpointIPtr _endpoint;
-    EndpointIPtr _publishedEndpoint;
+        AcceptorPtr _acceptor;
+        const TransceiverPtr _transceiver;
+        EndpointIPtr _endpoint;
 
-    bool _acceptorStarted;
-    bool _acceptorStopped;
+        bool _acceptorStarted{false};
+#if defined(__APPLE__) && TARGET_OS_IPHONE != 0
+        bool _acceptorStopped{false};
+#endif
 
-    Ice::ObjectAdapterIPtr _adapter;
-    const bool _warn;
-    std::set<Ice::ConnectionIPtr> _connections;
-    State _state;
+        std::shared_ptr<Ice::ObjectAdapterI> _adapter;
+        const bool _warn;
+        std::set<Ice::ConnectionIPtr> _connections;
+        State _state{StateHolding};
 
 #if defined(ICE_USE_IOCP)
-    IceInternal::UniquePtr<Ice::LocalException> _acceptorException;
+        std::exception_ptr _acceptorException;
 #endif
-};
+        mutable std::mutex _mutex;
+        mutable std::condition_variable _conditionVariable;
 
+        // For locking the _mutex
+        template<typename T> friend class IceInternal::ThreadPoolMessage;
+    };
 }
 
 #endif

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

@@ -1,30 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_CONNECTION_FACTORY_F_H
 #define ICE_CONNECTION_FACTORY_F_H
 
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
+    class OutgoingConnectionFactory;
+    using OutgoingConnectionFactoryPtr = std::shared_ptr<OutgoingConnectionFactory>;
 
-class OutgoingConnectionFactory;
-IceUtil::Shared* upCast(OutgoingConnectionFactory*);
-typedef IceInternal::Handle<OutgoingConnectionFactory> OutgoingConnectionFactoryPtr;
-
-class IncomingConnectionFactory;
-
-#ifdef ICE_CPP11_MAPPING
-using IncomingConnectionFactoryPtr = ::std::shared_ptr<IncomingConnectionFactory>;
-#else
-IceUtil::Shared* upCast(IncomingConnectionFactory*);
-typedef IceInternal::Handle<IncomingConnectionFactory> IncomingConnectionFactoryPtr;
-#endif
-
+    class IncomingConnectionFactory;
+    using IncomingConnectionFactoryPtr = std::shared_ptr<IncomingConnectionFactory>;
 }
 
 #endif