zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,255 +1,234 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_INSTRUMENTATION_I_H
 #define ICE_INSTRUMENTATION_I_H
 
-#include <Ice/MetricsObserverI.h>
-#include <Ice/Connection.h>
+#include "Ice/Connection.h"
+#include "MetricsObserverI.h"
 
 namespace IceInternal
 {
-
-template<typename T, typename O> class ObserverWithDelegateT : public IceMX::ObserverT<T>, public virtual O
-{
-public:
-
-    typedef O ObserverType;
-    typedef typename ICE_INTERNAL_HANDLE<O> ObserverPtrType;
-    virtual void
-    attach()
+    template<typename T, typename O> class ObserverWithDelegateT : public IceMX::ObserverT<T>, public virtual O
     {
-        IceMX::ObserverT<T>::attach();
-        if(_delegate)
+    public:
+        using ObserverType = O;
+        using ObserverPtrType = typename std::shared_ptr<O>;
+        void attach() override
         {
-            _delegate->attach();
+            IceMX::ObserverT<T>::attach();
+            if (_delegate)
+            {
+                _delegate->attach();
+            }
         }
-    }
 
-    virtual void
-    detach()
-    {
-        IceMX::ObserverT<T>::detach();
-        if(_delegate)
+        void detach() override
         {
-            _delegate->detach();
+            IceMX::ObserverT<T>::detach();
+            if (_delegate)
+            {
+                _delegate->detach();
+            }
         }
-    }
 
-    virtual void
-    failed(const std::string& exceptionName)
-    {
-        IceMX::ObserverT<T>::failed(exceptionName);
-        if(_delegate)
+        void failed(const std::string& exceptionName) override
         {
-            _delegate->failed(exceptionName);
+            IceMX::ObserverT<T>::failed(exceptionName);
+            if (_delegate)
+            {
+                _delegate->failed(exceptionName);
+            }
         }
-    }
 
-    ObserverPtrType
-    getDelegate() const
-    {
-        return _delegate;
-    }
+        [[nodiscard]] ObserverPtrType getDelegate() const { return _delegate; }
 
-    void
-    setDelegate(ObserverPtrType delegate)
-    {
-        _delegate = delegate;
-    }
+        void setDelegate(ObserverPtrType delegate) { _delegate = std::move(delegate); }
 
-    template<typename ObserverImpl, typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType
-    getObserverWithDelegate(const std::string& mapName, const IceMX::MetricsHelperT<ObserverMetricsType>& helper,
-                            const ObserverPtrType& del)
-    {
-        ICE_INTERNAL_HANDLE<ObserverImpl> obsv = IceMX::ObserverT<T>::template getObserver<ObserverImpl>(mapName,
-                                                                                                         helper);
-        if(obsv)
+        template<typename ObserverImpl, typename ObserverMetricsType, typename ObserverPtrType>
+        ObserverPtrType getObserverWithDelegate(
+            const std::string& mapName,
+            const IceMX::MetricsHelperT<ObserverMetricsType>& helper,
+            const ObserverPtrType& del)
         {
-            obsv->setDelegate(del);
-            return obsv;
+            std::shared_ptr<ObserverImpl> obsv =
+                IceMX::ObserverT<T>::template getObserver<ObserverImpl>(mapName, helper);
+            if (obsv)
+            {
+                obsv->setDelegate(del);
+                return obsv;
+            }
+            return del;
         }
-        return del;
-    }
 
-protected:
-
-    ObserverPtrType _delegate;
-};
+    protected:
+        ObserverPtrType _delegate;
+    };
 
-template<typename T> class ObserverFactoryWithDelegateT : public IceMX::ObserverFactoryT<T>
-{
-public:
-
-    ObserverFactoryWithDelegateT(const IceInternal::MetricsAdminIPtr& metrics, const std::string& name) :
-        IceMX::ObserverFactoryT<T>(metrics, name)
-    {
-    }
-
-    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType
-    getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del)
+    template<typename T> class ObserverFactoryWithDelegateT : public IceMX::ObserverFactoryT<T>
     {
-        ICE_INTERNAL_HANDLE<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper);
-        if(obsv)
+    public:
+        ObserverFactoryWithDelegateT(const IceInternal::MetricsAdminIPtr& metrics, const std::string& name)
+            : IceMX::ObserverFactoryT<T>(metrics, name)
         {
-            obsv->setDelegate(del);
-            return obsv;
         }
-        return del;
-    }
 
-    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType
-    getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del,
-                            const ObserverPtrType& old)
-    {
-        ICE_INTERNAL_HANDLE<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper, old);
-        if(obsv)
+        template<typename ObserverMetricsType, typename ObserverPtrType>
+        ObserverPtrType
+        getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del)
         {
-            obsv->setDelegate(del);
-            return obsv;
+            std::shared_ptr<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper);
+            if (obsv)
+            {
+                obsv->setDelegate(del);
+                return obsv;
+            }
+            return del;
         }
-        return del;
-    }
-};
-
-template<typename Helper>
-void addEndpointAttributes(typename Helper::Attributes& attrs)
-{
-    attrs.add("endpoint", &Helper::getEndpoint);
-
-    attrs.add("endpointType", &Helper::getEndpointInfo, &Ice::EndpointInfo::type);
-    attrs.add("endpointIsDatagram", &Helper::getEndpointInfo, &Ice::EndpointInfo::datagram);
-    attrs.add("endpointIsSecure", &Helper::getEndpointInfo, &Ice::EndpointInfo::secure);
-    attrs.add("endpointTimeout", &Helper::getEndpointInfo, &Ice::EndpointInfo::timeout);
-    attrs.add("endpointCompress", &Helper::getEndpointInfo, &Ice::EndpointInfo::compress);
-
-    attrs.add("endpointHost", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::host);
-    attrs.add("endpointPort", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::port);
-}
-
-template<typename Helper>
-void addConnectionAttributes(typename Helper::Attributes& attrs)
-{
-    attrs.add("incoming", &Helper::getConnectionInfo, &Ice::ConnectionInfo::incoming);
-    attrs.add("adapterName", &Helper::getConnectionInfo, &Ice::ConnectionInfo::adapterName);
-    attrs.add("connectionId", &Helper::getConnectionInfo, &Ice::ConnectionInfo::connectionId);
 
-    attrs.add("localHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localAddress);
-    attrs.add("localPort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localPort);
-    attrs.add("remoteHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remoteAddress);
-    attrs.add("remotePort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remotePort);
-
-    attrs.add("mcastHost", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastAddress);
-    attrs.add("mcastPort", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastPort);
-
-    addEndpointAttributes<Helper>(attrs);
-}
+        template<typename ObserverMetricsType, typename ObserverPtrType>
+        ObserverPtrType getObserverWithDelegate(
+            const IceMX::MetricsHelperT<ObserverMetricsType>& helper,
+            const ObserverPtrType& del,
+            const ObserverPtrType& old)
+        {
+            std::shared_ptr<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper, old);
+            if (obsv)
+            {
+                obsv->setDelegate(del);
+                return obsv;
+            }
+            return del;
+        }
+    };
 
-class ConnectionObserverI : public ObserverWithDelegateT<IceMX::ConnectionMetrics,
-                                                         Ice::Instrumentation::ConnectionObserver>
-{
-public:
+    template<typename Helper> void addEndpointAttributes(typename Helper::Attributes& attrs)
+    {
+        attrs.add("endpoint", &Helper::getEndpoint);
 
-    virtual void sentBytes(Ice::Int);
-    virtual void receivedBytes(Ice::Int);
-};
+        attrs.add("endpointType", &Helper::getEndpointInfo, &Ice::EndpointInfo::type);
+        attrs.add("endpointIsDatagram", &Helper::getEndpointInfo, &Ice::EndpointInfo::datagram);
+        attrs.add("endpointIsSecure", &Helper::getEndpointInfo, &Ice::EndpointInfo::secure);
+        attrs.add("endpointCompress", &Helper::getEndpointInfo, &Ice::EndpointInfo::compress);
 
-class ThreadObserverI : public ObserverWithDelegateT<IceMX::ThreadMetrics, Ice::Instrumentation::ThreadObserver>
-{
-public:
-
-    virtual void stateChanged(Ice::Instrumentation::ThreadState, Ice::Instrumentation::ThreadState);
-};
+        attrs.add("endpointHost", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::host);
+        attrs.add("endpointPort", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::port);
+    }
 
-class DispatchObserverI : public ObserverWithDelegateT<IceMX::DispatchMetrics, Ice::Instrumentation::DispatchObserver>
-{
-public:
+    template<typename Helper> void addConnectionAttributes(typename Helper::Attributes& attrs)
+    {
+        attrs.add("incoming", &Helper::getConnectionInfo, &Ice::ConnectionInfo::incoming);
+        attrs.add("adapterName", &Helper::getConnectionInfo, &Ice::ConnectionInfo::adapterName);
+        attrs.add("connectionId", &Helper::getConnectionInfo, &Ice::ConnectionInfo::connectionId);
 
-    virtual void userException();
+        attrs.add("localHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localAddress);
+        attrs.add("localPort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localPort);
+        attrs.add("remoteHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remoteAddress);
+        attrs.add("remotePort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remotePort);
 
-    virtual void reply(Ice::Int);
-};
+        attrs.add("mcastHost", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastAddress);
+        attrs.add("mcastPort", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastPort);
 
-class RemoteObserverI : public ObserverWithDelegateT<IceMX::RemoteMetrics, Ice::Instrumentation::RemoteObserver>
-{
-public:
+        addEndpointAttributes<Helper>(attrs);
+    }
 
-    virtual void reply(Ice::Int);
-};
+    class ConnectionObserverI
+        : public ObserverWithDelegateT<IceMX::ConnectionMetrics, Ice::Instrumentation::ConnectionObserver>
+    {
+    public:
+        void sentBytes(std::int32_t) override;
+        void receivedBytes(std::int32_t) override;
+    };
 
-class CollocatedObserverI : public ObserverWithDelegateT<IceMX::CollocatedMetrics,
-                                                         Ice::Instrumentation::CollocatedObserver>
-{
-public:
+    class ThreadObserverI : public ObserverWithDelegateT<IceMX::ThreadMetrics, Ice::Instrumentation::ThreadObserver>
+    {
+    public:
+        void stateChanged(Ice::Instrumentation::ThreadState, Ice::Instrumentation::ThreadState) override;
+    };
 
-    virtual void reply(Ice::Int);
-};
+    class DispatchObserverI
+        : public ObserverWithDelegateT<IceMX::DispatchMetrics, Ice::Instrumentation::DispatchObserver>
+    {
+    public:
+        void userException() override;
 
-class InvocationObserverI : public ObserverWithDelegateT<IceMX::InvocationMetrics,
-                                                         Ice::Instrumentation::InvocationObserver>
-{
-public:
+        void reply(std::int32_t) override;
+    };
 
-    virtual void retried();
+    class RemoteObserverI : public ObserverWithDelegateT<IceMX::RemoteMetrics, Ice::Instrumentation::RemoteObserver>
+    {
+    public:
+        void reply(std::int32_t) override;
+    };
 
-    virtual void userException();
+    class CollocatedObserverI
+        : public ObserverWithDelegateT<IceMX::CollocatedMetrics, Ice::Instrumentation::CollocatedObserver>
+    {
+    public:
+        void reply(std::int32_t) override;
+    };
 
-    virtual Ice::Instrumentation::RemoteObserverPtr
-    getRemoteObserver(const Ice::ConnectionInfoPtr&, const Ice::EndpointPtr&, Ice::Int, Ice::Int);
+    class InvocationObserverI
+        : public ObserverWithDelegateT<IceMX::InvocationMetrics, Ice::Instrumentation::InvocationObserver>
+    {
+    public:
+        void retried() override;
 
-    virtual Ice::Instrumentation::CollocatedObserverPtr
-    getCollocatedObserver(const Ice::ObjectAdapterPtr&, Ice::Int, Ice::Int);
-};
+        void userException() override;
 
-typedef ObserverWithDelegateT<IceMX::Metrics, Ice::Instrumentation::Observer> ObserverI;
+        Ice::Instrumentation::RemoteObserverPtr
+        getRemoteObserver(const Ice::ConnectionInfoPtr&, const Ice::EndpointPtr&, std::int32_t, std::int32_t) override;
 
-class ICE_API CommunicatorObserverI : public Ice::Instrumentation::CommunicatorObserver
-{
-public:
+        Ice::Instrumentation::CollocatedObserverPtr
+        getCollocatedObserver(const Ice::ObjectAdapterPtr&, std::int32_t, std::int32_t) override;
+    };
 
-    CommunicatorObserverI(const Ice::InitializationData&);
+    using ObserverI = ObserverWithDelegateT<IceMX::Metrics, Ice::Instrumentation::Observer>;
 
-    virtual void setObserverUpdater(const Ice::Instrumentation::ObserverUpdaterPtr&);
+    class ICE_API CommunicatorObserverI : public Ice::Instrumentation::CommunicatorObserver
+    {
+    public:
+        CommunicatorObserverI(const Ice::InitializationData&);
 
-    virtual Ice::Instrumentation::ObserverPtr getConnectionEstablishmentObserver(const Ice::EndpointPtr&,
-                                                                                 const std::string&);
+        void setObserverUpdater(const Ice::Instrumentation::ObserverUpdaterPtr&) override;
 
-    virtual Ice::Instrumentation::ObserverPtr getEndpointLookupObserver(const Ice::EndpointPtr&);
+        Ice::Instrumentation::ObserverPtr
+        getConnectionEstablishmentObserver(const Ice::EndpointPtr&, const std::string&) override;
 
-    virtual Ice::Instrumentation::ConnectionObserverPtr
-    getConnectionObserver(const Ice::ConnectionInfoPtr&,
-                          const Ice::EndpointPtr&,
-                          Ice::Instrumentation::ConnectionState,
-                          const Ice::Instrumentation::ConnectionObserverPtr&);
+        Ice::Instrumentation::ObserverPtr getEndpointLookupObserver(const Ice::EndpointPtr&) override;
 
-    virtual Ice::Instrumentation::ThreadObserverPtr getThreadObserver(const std::string&, const std::string&,
-                                                                      Ice::Instrumentation::ThreadState,
-                                                                      const Ice::Instrumentation::ThreadObserverPtr&);
+        Ice::Instrumentation::ConnectionObserverPtr getConnectionObserver(
+            const Ice::ConnectionInfoPtr&,
+            const Ice::EndpointPtr&,
+            Ice::Instrumentation::ConnectionState,
+            const Ice::Instrumentation::ConnectionObserverPtr&) override;
 
-    virtual Ice::Instrumentation::InvocationObserverPtr getInvocationObserver(const Ice::ObjectPrxPtr&,
-                                                                              const std::string&,
-                                                                              const Ice::Context&);
+        Ice::Instrumentation::ThreadObserverPtr getThreadObserver(
+            const std::string&,
+            const std::string&,
+            Ice::Instrumentation::ThreadState,
+            const Ice::Instrumentation::ThreadObserverPtr&) override;
 
-    virtual Ice::Instrumentation::DispatchObserverPtr getDispatchObserver(const Ice::Current&, Ice::Int);
+        Ice::Instrumentation::InvocationObserverPtr
+        getInvocationObserver(const std::optional<Ice::ObjectPrx>&, std::string_view, const Ice::Context&) override;
 
-    const IceInternal::MetricsAdminIPtr& getFacet() const;
+        Ice::Instrumentation::DispatchObserverPtr getDispatchObserver(const Ice::Current&, std::int32_t) override;
 
-    void destroy();
+        [[nodiscard]] const IceInternal::MetricsAdminIPtr& getFacet() const;
 
-private:
+        void destroy();
 
-    IceInternal::MetricsAdminIPtr _metrics;
-    const Ice::Instrumentation::CommunicatorObserverPtr _delegate;
+    private:
+        IceInternal::MetricsAdminIPtr _metrics;
+        const Ice::Instrumentation::CommunicatorObserverPtr _delegate;
 
-    ObserverFactoryWithDelegateT<ConnectionObserverI> _connections;
-    ObserverFactoryWithDelegateT<DispatchObserverI> _dispatch;
-    ObserverFactoryWithDelegateT<InvocationObserverI> _invocations;
-    ObserverFactoryWithDelegateT<ThreadObserverI> _threads;
-    ObserverFactoryWithDelegateT<ObserverI> _connects;
-    ObserverFactoryWithDelegateT<ObserverI> _endpointLookups;
-};
-ICE_DEFINE_PTR(CommunicatorObserverIPtr, CommunicatorObserverI);
+        ObserverFactoryWithDelegateT<ConnectionObserverI> _connections;
+        ObserverFactoryWithDelegateT<DispatchObserverI> _dispatch;
+        ObserverFactoryWithDelegateT<InvocationObserverI> _invocations;
+        ObserverFactoryWithDelegateT<ThreadObserverI> _threads;
+        ObserverFactoryWithDelegateT<ObserverI> _connects;
+        ObserverFactoryWithDelegateT<ObserverI> _endpointLookups;
+    };
+    using CommunicatorObserverIPtr = std::shared_ptr<CommunicatorObserverI>;
 
 };