zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,15 +1,11 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/InstrumentationI.h>
-
-#include <Ice/Connection.h>
-#include <Ice/Endpoint.h>
-#include <Ice/ObjectAdapter.h>
-#include <Ice/LocalException.h>
-#include <Ice/Communicator.h>
-#include <Ice/LoggerUtil.h>
+#include "InstrumentationI.h"
+#include "Ice/Communicator.h"
+#include "Ice/Connection.h"
+#include "Ice/Endpoint.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/ObjectAdapter.h"
 
 using namespace std;
 using namespace Ice;
@@ -17,772 +13,637 @@ using namespace IceInternal;
 using namespace Ice::Instrumentation;
 using namespace IceMX;
 
-#ifdef ICE_CPP11_MAPPING
-#  define ICE_OBJECT_PRX Ice::ObjectPrx
-#else
-#  define ICE_OBJECT_PRX IceProxy::Ice::Object
-#endif
-
 namespace
 {
-
-int ThreadMetrics::*
-getThreadStateMetric(ThreadState s)
-{
-    switch(s)
+    int ThreadMetrics::* getThreadStateMetric(ThreadState s)
     {
-        case ICE_ENUM(ThreadState, ThreadStateIdle):
-            return 0;
-        case ICE_ENUM(ThreadState, ThreadStateInUseForIO):
-            return &ThreadMetrics::inUseForIO;
-        case ICE_ENUM(ThreadState, ThreadStateInUseForUser):
-            return &ThreadMetrics::inUseForUser;
-        case ICE_ENUM(ThreadState, ThreadStateInUseForOther):
-            return &ThreadMetrics::inUseForOther;
-        default:
-            assert(false);
-            return 0;
+        switch (s)
+        {
+            case ThreadState::ThreadStateIdle:
+                return nullptr;
+            case ThreadState::ThreadStateInUseForIO:
+                return &ThreadMetrics::inUseForIO;
+            case ThreadState::ThreadStateInUseForUser:
+                return &ThreadMetrics::inUseForUser;
+            case ThreadState::ThreadStateInUseForOther:
+                return &ThreadMetrics::inUseForOther;
+            default:
+                assert(false);
+                return nullptr;
+        }
     }
-}
 
-struct ThreadStateChanged
-{
-    ThreadStateChanged(ThreadState oldStateP, ThreadState newStateP) : oldState(oldStateP), newState(newStateP)
+    struct ThreadStateChanged
     {
-    }
+        ThreadStateChanged(ThreadState oldStateP, ThreadState newStateP) : oldState(oldStateP), newState(newStateP) {}
 
-    void operator()(const ThreadMetricsPtr& v)
-    {
-        if(oldState != ICE_ENUM(ThreadState, ThreadStateIdle))
+        void operator()(const ThreadMetricsPtr& v)
         {
-            --(v.get()->*getThreadStateMetric(oldState));
-        }
-        if(newState != ICE_ENUM(ThreadState, ThreadStateIdle))
-        {
-            ++(v.get()->*getThreadStateMetric(newState));
+            if (oldState != ThreadState::ThreadStateIdle)
+            {
+                --(v.get()->*getThreadStateMetric(oldState));
+            }
+            if (newState != ThreadState::ThreadStateIdle)
+            {
+                ++(v.get()->*getThreadStateMetric(newState));
+            }
         }
-    }
 
-    ThreadState oldState;
-    ThreadState newState;
-};
+        ThreadState oldState;
+        ThreadState newState;
+    };
 
-IPConnectionInfo*
-getIPConnectionInfo(const ConnectionInfoPtr& info)
-{
-    for(ConnectionInfoPtr p = info; p; p = p->underlying)
+    IPConnectionInfoPtr getIPConnectionInfo(const ConnectionInfoPtr& info)
     {
-        IPConnectionInfo* ipInfo = dynamic_cast<IPConnectionInfo*>(p.get());
-        if(ipInfo)
+        for (ConnectionInfoPtr p = info; p; p = p->underlying)
         {
-            return ipInfo;
+            IPConnectionInfoPtr ipInfo = dynamic_pointer_cast<IPConnectionInfo>(p);
+            if (ipInfo)
+            {
+                return ipInfo;
+            }
         }
+        return nullptr;
     }
-    return ICE_NULLPTR;
-}
 
-class ConnectionHelper : public MetricsHelperT<ConnectionMetrics>
-{
-public:
-
-    class Attributes : public AttributeResolverT<ConnectionHelper>
+    class ConnectionHelper : public MetricsHelperT<ConnectionMetrics>
     {
     public:
+        class Attributes : public AttributeResolverT<ConnectionHelper>
+        {
+        public:
+            Attributes() noexcept
+            {
+                add("parent", &ConnectionHelper::getParent);
+                add("id", &ConnectionHelper::getId);
+                add("state", &ConnectionHelper::getState);
+                addConnectionAttributes<ConnectionHelper>(*this);
+            }
+        };
+        static Attributes attributes;
 
-        Attributes()
+        ConnectionHelper(const ConnectionInfoPtr& con, const EndpointPtr& endpt, ConnectionState state)
+            : _connectionInfo(con),
+              _endpoint(endpt),
+              _state(state)
         {
-            add("parent", &ConnectionHelper::getParent);
-            add("id", &ConnectionHelper::getId);
-            add("state", &ConnectionHelper::getState);
-            addConnectionAttributes<ConnectionHelper>(*this);
         }
-    };
-    static Attributes attributes;
 
-    ConnectionHelper(const ConnectionInfoPtr& con, const EndpointPtr& endpt, ConnectionState state) :
-        _connectionInfo(con), _endpoint(endpt), _state(state)
-    {
-    }
+        string operator()(const string& attribute) const override { return attributes(this, attribute); }
 
-    virtual string operator()(const string& attribute) const
-    {
-        return attributes(this, attribute);
-    }
-
-    const string&
-    getId() const
-    {
-        if(_id.empty())
+        [[nodiscard]] const string& getId() const
         {
-            ostringstream os;
-            IPConnectionInfo* info = getIPConnectionInfo(_connectionInfo);
-            if(info)
+            if (_id.empty())
             {
-                os << info->localAddress << ':' << info->localPort;
-                os << " -> ";
-                os << info->remoteAddress << ':' << info->remotePort;
-            }
-            else
-            {
-                os << "connection-" << _connectionInfo.get();
-            }
-            if(!_connectionInfo->connectionId.empty())
-            {
-                os << " [" << _connectionInfo->connectionId << "]";
+                ostringstream os;
+                IPConnectionInfoPtr info = getIPConnectionInfo(_connectionInfo);
+                if (info)
+                {
+                    os << info->localAddress << ':' << info->localPort;
+                    os << " -> ";
+                    os << info->remoteAddress << ':' << info->remotePort;
+                }
+                else
+                {
+                    os << "connection-" << _connectionInfo.get();
+                }
+                if (!_connectionInfo->connectionId.empty())
+                {
+                    os << " [" << _connectionInfo->connectionId << "]";
+                }
+                _id = os.str();
             }
-            _id = os.str();
+            return _id;
         }
-        return _id;
-    }
 
-    string
-    getState() const
-    {
-        switch(_state)
+        [[nodiscard]] string getState() const
         {
-            case ICE_ENUM(ConnectionState, ConnectionStateValidating):
-                return "validating";
-            case ICE_ENUM(ConnectionState, ConnectionStateHolding):
-                return "holding";
-            case ICE_ENUM(ConnectionState, ConnectionStateActive):
-                return "active";
-            case ICE_ENUM(ConnectionState, ConnectionStateClosing):
-                return "closing";
-            case ICE_ENUM(ConnectionState, ConnectionStateClosed):
-                return "closed";
-            default:
-                assert(false);
-                return "";
+            switch (_state)
+            {
+                case ConnectionState::ConnectionStateValidating:
+                    return "validating";
+                case ConnectionState::ConnectionStateHolding:
+                    return "holding";
+                case ConnectionState::ConnectionStateActive:
+                    return "active";
+                case ConnectionState::ConnectionStateClosing:
+                    return "closing";
+                case ConnectionState::ConnectionStateClosed:
+                    return "closed";
+                default:
+                    assert(false);
+                    return "";
+            }
         }
-    }
 
-    string
-    getParent() const
-    {
-        if(!_connectionInfo->adapterName.empty())
-        {
-            return _connectionInfo->adapterName;
-        }
-        else
+        [[nodiscard]] string getParent() const
         {
-            return "Communicator";
+            if (!_connectionInfo->adapterName.empty())
+            {
+                return _connectionInfo->adapterName;
+            }
+            else
+            {
+                return "Communicator";
+            }
         }
-    }
 
-    const ConnectionInfoPtr&
-    getConnectionInfo() const
-    {
-        return _connectionInfo;
-    }
+        [[nodiscard]] const ConnectionInfoPtr& getConnectionInfo() const { return _connectionInfo; }
 
-    const EndpointPtr&
-    getEndpoint() const
-    {
-        return _endpoint;
-    }
+        [[nodiscard]] const EndpointPtr& getEndpoint() const { return _endpoint; }
 
-    const EndpointInfoPtr&
-    getEndpointInfo() const
-    {
-        if(!_endpointInfo)
+        [[nodiscard]] const EndpointInfoPtr& getEndpointInfo() const
         {
-            _endpointInfo = _endpoint->getInfo();
+            if (!_endpointInfo)
+            {
+                _endpointInfo = _endpoint->getInfo();
+            }
+            return _endpointInfo;
         }
-        return _endpointInfo;
-    }
-
-private:
 
-    const ConnectionInfoPtr& _connectionInfo;
-    const EndpointPtr& _endpoint;
-    const ConnectionState _state;
-    mutable string _id;
-    mutable EndpointInfoPtr _endpointInfo;
-};
-
-ConnectionHelper::Attributes ConnectionHelper::attributes;
+    private:
+        const ConnectionInfoPtr& _connectionInfo;
+        const EndpointPtr& _endpoint;
+        const ConnectionState _state;
+        mutable string _id;
+        mutable EndpointInfoPtr _endpointInfo;
+    };
 
-class DispatchHelper : public MetricsHelperT<DispatchMetrics>
-{
-public:
+    ConnectionHelper::Attributes ConnectionHelper::attributes;
 
-    class Attributes : public AttributeResolverT<DispatchHelper>
+    class DispatchHelper : public MetricsHelperT<DispatchMetrics>
     {
     public:
-
-        Attributes()
+        class Attributes : public AttributeResolverT<DispatchHelper>
         {
-            add("parent", &DispatchHelper::getParent);
-            add("id", &DispatchHelper::getId);
-            add("connection", &DispatchHelper::getConnection);
+        public:
+            Attributes() noexcept
+            {
+                add("parent", &DispatchHelper::getParent);
+                add("id", &DispatchHelper::getId);
+                add("connection", &DispatchHelper::getConnection);
 
-            addConnectionAttributes<DispatchHelper>(*this);
+                addConnectionAttributes<DispatchHelper>(*this);
 
-            add("operation", &DispatchHelper::getCurrent, &Current::operation);
-            add("identity", &DispatchHelper::getIdentity);
-            add("facet", &DispatchHelper::getCurrent, &Current::facet);
-            add("mode", &DispatchHelper::getMode);
-            add("requestId", &DispatchHelper::getCurrent, &Current::requestId);
+                add("operation", &DispatchHelper::getCurrent, &Current::operation);
+                add("identity", &DispatchHelper::getIdentity);
+                add("facet", &DispatchHelper::getCurrent, &Current::facet);
+                add("mode", &DispatchHelper::getMode);
+                add("requestId", &DispatchHelper::getCurrent, &Current::requestId);
 
-            setDefault(&DispatchHelper::resolve);
-        }
-    };
-    static Attributes attributes;
+                setDefault(&DispatchHelper::resolve);
+            }
+        };
+        static Attributes attributes;
 
-    DispatchHelper(const Current& current, int size) : _current(current), _size(size)
-    {
-    }
+        DispatchHelper(const Current& current, int size) : _current(current), _size(size) {}
 
-    virtual string operator()(const string& attribute) const
-    {
-        return attributes(this, attribute);
-    }
+        string operator()(const string& attribute) const override { return attributes(this, attribute); }
 
-    virtual void initMetrics(const DispatchMetricsPtr& v) const
-    {
-        v->size += _size;
-    }
+        void initMetrics(const DispatchMetricsPtr& v) const override { v->size += _size; }
 
-    string resolve(const string& attribute) const
-    {
-        if(attribute.compare(0, 8, "context.") == 0)
+        [[nodiscard]] string resolve(const string& attribute) const
         {
-            Context::const_iterator p = _current.ctx.find(attribute.substr(8));
-            if(p != _current.ctx.end())
+            if (attribute.compare(0, 8, "context.") == 0)
             {
-                return p->second;
+                auto p = _current.ctx.find(attribute.substr(8));
+                if (p != _current.ctx.end())
+                {
+                    return p->second;
+                }
             }
+            throw invalid_argument(attribute);
         }
-        throw invalid_argument(attribute);
-    }
 
-    string
-    getMode() const
-    {
-        return _current.requestId == 0 ? "oneway" : "twoway";
-    }
+        [[nodiscard]] string getMode() const { return _current.requestId == 0 ? "oneway" : "twoway"; }
 
-    const string&
-    getId() const
-    {
-        if(_id.empty())
+        [[nodiscard]] const string& getId() const
         {
-            ostringstream os;
-            if(!_current.id.category.empty())
+            if (_id.empty())
             {
-                os << _current.id.category << '/';
+                ostringstream os;
+                if (!_current.id.category.empty())
+                {
+                    os << _current.id.category << '/';
+                }
+                os << _current.id.name << " [" << _current.operation << ']';
+                _id = os.str();
             }
-            os << _current.id.name << " [" << _current.operation << ']';
-            _id = os.str();
+            return _id;
         }
-        return _id;
-    }
 
-    string
-    getParent() const
-    {
-        return _current.adapter->getName();
-    }
+        [[nodiscard]] string getParent() const { return _current.adapter->getName(); }
 
-    ConnectionInfoPtr
-    getConnectionInfo() const
-    {
-        if(_current.con)
+        [[nodiscard]] ConnectionInfoPtr getConnectionInfo() const
         {
-            return _current.con->getInfo();
+            if (_current.con)
+            {
+                return _current.con->getInfo();
+            }
+            return nullptr;
         }
-        return 0;
-    }
 
-    EndpointPtr
-    getEndpoint() const
-    {
-        if(_current.con)
+        [[nodiscard]] EndpointPtr getEndpoint() const
         {
-            return _current.con->getEndpoint();
+            if (_current.con)
+            {
+                return _current.con->getEndpoint();
+            }
+            return nullptr;
         }
-        return 0;
-    }
 
-    const ConnectionPtr&
-    getConnection() const
-    {
-        return _current.con;
-    }
+        [[nodiscard]] const ConnectionPtr& getConnection() const { return _current.con; }
 
-    const EndpointInfoPtr&
-    getEndpointInfo() const
-    {
-        if(_current.con && !_endpointInfo)
+        [[nodiscard]] const EndpointInfoPtr& getEndpointInfo() const
         {
-            _endpointInfo = _current.con->getEndpoint()->getInfo();
+            if (_current.con && !_endpointInfo)
+            {
+                _endpointInfo = _current.con->getEndpoint()->getInfo();
+            }
+            return _endpointInfo;
         }
-        return _endpointInfo;
-    }
-
-    const Current&
-    getCurrent() const
-    {
-        return _current;
-    }
-
-    string
-    getIdentity() const
-    {
-        return _current.adapter->getCommunicator()->identityToString(_current.id);
-    }
 
-private:
+        [[nodiscard]] const Current& getCurrent() const { return _current; }
 
-    const Current& _current;
-    const int _size;
-    mutable string _id;
-    mutable EndpointInfoPtr _endpointInfo;
-};
+        [[nodiscard]] string getIdentity() const
+        {
+            return _current.adapter->getCommunicator()->identityToString(_current.id);
+        }
 
-DispatchHelper::Attributes DispatchHelper::attributes;
+    private:
+        const Current& _current;
+        const int _size;
+        mutable string _id;
+        mutable EndpointInfoPtr _endpointInfo;
+    };
 
-class InvocationHelper : public MetricsHelperT<InvocationMetrics>
-{
-public:
+    DispatchHelper::Attributes DispatchHelper::attributes;
 
-    class Attributes : public AttributeResolverT<InvocationHelper>
+    class InvocationHelper : public MetricsHelperT<InvocationMetrics>
     {
     public:
-
-        Attributes()
+        class Attributes : public AttributeResolverT<InvocationHelper>
+        {
+        public:
+            Attributes() noexcept
+            {
+                add("parent", &InvocationHelper::getParent);
+                add("id", &InvocationHelper::getId);
+                add("operation", &InvocationHelper::getOperation);
+                add("identity", &InvocationHelper::getIdentity);
+                add("facet", &InvocationHelper::getProxy, &Ice::ObjectPrx::ice_getFacet);
+                add("encoding", &InvocationHelper::getProxy, &Ice::ObjectPrx::ice_getEncodingVersion);
+                add("mode", &InvocationHelper::getMode);
+                add("proxy", &InvocationHelper::getProxy);
+
+                setDefault(&InvocationHelper::resolve);
+            }
+        };
+        static Attributes attributes;
+        InvocationHelper(const optional<ObjectPrx>& proxy, string_view op, const Context& ctx)
+            : _proxy(proxy),
+              _operation(op),
+              _context(ctx)
         {
-            add("parent", &InvocationHelper::getParent);
-            add("id", &InvocationHelper::getId);
-
-            add("operation", &InvocationHelper::getOperation);
-            add("identity", &InvocationHelper::getIdentity);
-            add("facet", &InvocationHelper::getProxy, &ICE_OBJECT_PRX::ice_getFacet);
-            add("encoding", &InvocationHelper::getProxy, &ICE_OBJECT_PRX::ice_getEncodingVersion);
-            add("mode", &InvocationHelper::getMode);
-            add("proxy", &InvocationHelper::getProxy);
-
-            setDefault(&InvocationHelper::resolve);
         }
-    };
-    static Attributes attributes;
-    InvocationHelper(const ObjectPrxPtr& proxy, const string& op, const Context& ctx) :
-        _proxy(proxy), _operation(op), _context(ctx)
-    {
-    }
 
-    string resolve(const string& attribute) const
-    {
-        if(attribute.compare(0, 8, "context.") == 0)
+        [[nodiscard]] string resolve(const string& attribute) const
         {
-            Context::const_iterator p = _context.find(attribute.substr(8));
-            if(p != _context.end())
+            if (attribute.compare(0, 8, "context.") == 0)
             {
-                return p->second;
+                auto p = _context.find(attribute.substr(8));
+                if (p != _context.end())
+                {
+                    return p->second;
+                }
             }
+            throw invalid_argument(attribute);
         }
-        throw invalid_argument(attribute);
-    }
 
-    virtual string operator()(const string& attribute) const
-    {
-        return attributes(this, attribute);
-    }
+        string operator()(const string& attribute) const override { return attributes(this, attribute); }
 
-    string
-    getMode() const
-    {
-        if(!_proxy)
+        [[nodiscard]] string getMode() const
         {
-            throw invalid_argument("mode");
-        }
+            if (!_proxy)
+            {
+                throw invalid_argument("mode");
+            }
 
-        if(_proxy->ice_isTwoway())
-        {
-            return "twoway";
-        }
-        else if(_proxy->ice_isOneway())
-        {
-            return "oneway";
-        }
-        else if(_proxy->ice_isBatchOneway())
-        {
-            return "batch-oneway";
-        }
-        else if(_proxy->ice_isDatagram())
-        {
-            return "datagram";
-        }
-        else if(_proxy->ice_isBatchDatagram())
-        {
-            return "batch-datagram";
-        }
-        else
-        {
-            throw invalid_argument("mode");
+            if (_proxy->ice_isTwoway())
+            {
+                return "twoway";
+            }
+            else if (_proxy->ice_isOneway())
+            {
+                return "oneway";
+            }
+            else if (_proxy->ice_isBatchOneway())
+            {
+                return "batch-oneway";
+            }
+            else if (_proxy->ice_isDatagram())
+            {
+                return "datagram";
+            }
+            else if (_proxy->ice_isBatchDatagram())
+            {
+                return "batch-datagram";
+            }
+            else
+            {
+                throw invalid_argument("mode");
+            }
         }
-    }
 
-    const string&
-    getId() const
-    {
-        if(_id.empty())
+        [[nodiscard]] const string& getId() const
         {
-            ostringstream os;
-            if(_proxy)
+            if (_id.empty())
             {
-                try
+                ostringstream os;
+                if (_proxy)
                 {
-                    os << _proxy->ice_endpoints(Ice::EndpointSeq())->ice_toString() << " [" << _operation << ']';
+                    try
+                    {
+                        os << _proxy->ice_endpoints(Ice::EndpointSeq())->ice_toString() << " [" << _operation << ']';
+                    }
+                    catch (const Exception&)
+                    {
+                        // Either a fixed proxy or the communicator is destroyed.
+                        os << _proxy->ice_getCommunicator()->identityToString(_proxy->ice_getIdentity());
+                        os << " [" << _operation << ']';
+                    }
                 }
-                catch(const Exception&)
+                else
                 {
-                    // Either a fixed proxy or the communicator is destroyed.
-                    os << _proxy->ice_getCommunicator()->identityToString(_proxy->ice_getIdentity());
-                    os << " [" << _operation << ']';
+                    os << _operation;
                 }
+                _id = os.str();
             }
-            else
-            {
-                os << _operation;
-            }
-            _id = os.str();
+            return _id;
         }
-        return _id;
-    }
 
-    string
-    getParent() const
-    {
-        return "Communicator";
-    }
+        [[nodiscard]] string getParent() const { return "Communicator"; }
 
-    const ObjectPrxPtr&
-    getProxy() const
-    {
-        return _proxy;
-    }
+        [[nodiscard]] const optional<ObjectPrx>& getProxy() const { return _proxy; }
 
-    string
-    getIdentity() const
-    {
-        if(_proxy)
-        {
-            return _proxy->ice_getCommunicator()->identityToString(_proxy->ice_getIdentity());
-        }
-        else
+        [[nodiscard]] string getIdentity() const
         {
-            return "";
+            if (_proxy)
+            {
+                return _proxy->ice_getCommunicator()->identityToString(_proxy->ice_getIdentity());
+            }
+            else
+            {
+                return "";
+            }
         }
-    }
 
-    const string&
-    getOperation() const
-    {
-        return _operation;
-    }
+        [[nodiscard]] string_view getOperation() const { return _operation; }
 
-private:
-
-    const ObjectPrxPtr& _proxy;
-    const string& _operation;
-    const Context& _context;
-    mutable string _id;
-};
-
-InvocationHelper::Attributes InvocationHelper::attributes;
+    private:
+        const optional<ObjectPrx>& _proxy;
+        string_view _operation;
+        const Context& _context;
+        mutable string _id;
+    };
 
-class RemoteInvocationHelper : public MetricsHelperT<RemoteMetrics>
-{
-public:
+    InvocationHelper::Attributes InvocationHelper::attributes;
 
-    class Attributes : public AttributeResolverT<RemoteInvocationHelper>
+    class RemoteInvocationHelper : public MetricsHelperT<RemoteMetrics>
     {
     public:
+        class Attributes : public AttributeResolverT<RemoteInvocationHelper>
+        {
+        public:
+            Attributes() noexcept
+            {
+                add("parent", &RemoteInvocationHelper::getParent);
+                add("id", &RemoteInvocationHelper::getId);
+                add("requestId", &RemoteInvocationHelper::_requestId);
+                addConnectionAttributes<RemoteInvocationHelper>(*this);
+            }
+        };
+        static Attributes attributes;
 
-        Attributes()
+        RemoteInvocationHelper(const ConnectionInfoPtr& con, const EndpointPtr& endpt, int requestId, int size)
+            : _connectionInfo(con),
+              _endpoint(endpt),
+              _requestId(requestId),
+              _size(size)
         {
-            add("parent", &RemoteInvocationHelper::getParent);
-            add("id", &RemoteInvocationHelper::getId);
-            add("requestId", &RemoteInvocationHelper::_requestId);
-            addConnectionAttributes<RemoteInvocationHelper>(*this);
         }
-    };
-    static Attributes attributes;
 
-    RemoteInvocationHelper(const ConnectionInfoPtr& con, const EndpointPtr& endpt, int requestId, int size) :
-        _connectionInfo(con), _endpoint(endpt), _requestId(requestId), _size(size)
-    {
-    }
-
-    virtual string operator()(const string& attribute) const
-    {
-        return attributes(this, attribute);
-    }
+        string operator()(const string& attribute) const override { return attributes(this, attribute); }
 
-    virtual void initMetrics(const RemoteMetricsPtr& v) const
-    {
-        v->size += _size;
-    }
+        void initMetrics(const RemoteMetricsPtr& v) const override { v->size += _size; }
 
-    const string&
-    getId() const
-    {
-        if(_id.empty())
+        [[nodiscard]] const string& getId() const
         {
-            _id = _endpoint->toString();
-            if(!_connectionInfo->connectionId.empty())
+            if (_id.empty())
             {
-                _id += " [" + _connectionInfo->connectionId + "]";
+                _id = _endpoint->toString();
+                if (!_connectionInfo->connectionId.empty())
+                {
+                    _id += " [" + _connectionInfo->connectionId + "]";
+                }
             }
+            return _id;
         }
-        return _id;
-    }
 
-    string
-    getParent() const
-    {
-        if(!_connectionInfo->adapterName.empty())
-        {
-            return _connectionInfo->adapterName;
-        }
-        else
+        [[nodiscard]] string getParent() const
         {
-            return "Communicator";
+            if (!_connectionInfo->adapterName.empty())
+            {
+                return _connectionInfo->adapterName;
+            }
+            else
+            {
+                return "Communicator";
+            }
         }
-    }
 
-    const ConnectionInfoPtr&
-    getConnectionInfo() const
-    {
-        return _connectionInfo;
-    }
+        [[nodiscard]] const ConnectionInfoPtr& getConnectionInfo() const { return _connectionInfo; }
 
-    const EndpointPtr&
-    getEndpoint() const
-    {
-        return _endpoint;
-    }
+        [[nodiscard]] const EndpointPtr& getEndpoint() const { return _endpoint; }
 
-    const EndpointInfoPtr&
-    getEndpointInfo() const
-    {
-        if(!_endpointInfo)
+        [[nodiscard]] const EndpointInfoPtr& getEndpointInfo() const
         {
-            _endpointInfo = _endpoint->getInfo();
+            if (!_endpointInfo)
+            {
+                _endpointInfo = _endpoint->getInfo();
+            }
+            return _endpointInfo;
         }
-        return _endpointInfo;
-    }
 
-private:
+    private:
+        const ConnectionInfoPtr& _connectionInfo;
+        const EndpointPtr& _endpoint;
 
-    const ConnectionInfoPtr& _connectionInfo;
-    const EndpointPtr& _endpoint;
+    protected:
+        //
+        // COMPILERFIX: Clang 4.2 reports unused-private-field for the _requestId
+        // field that is only used in the nested Attributes class.
+        //
+        const int _requestId;
 
-protected:
-    //
-    // COMPILERFIX: Clang 4.2 reports unused-private-field for the _requestId
-    // field that is only used in the nested Attributes class.
-    //
-    const int _requestId;
-
-private:
-    const int _size;
-    mutable string _id;
-    mutable EndpointInfoPtr _endpointInfo;
-};
-
-RemoteInvocationHelper::Attributes RemoteInvocationHelper::attributes;
+    private:
+        const int _size;
+        mutable string _id;
+        mutable EndpointInfoPtr _endpointInfo;
+    };
 
-class CollocatedInvocationHelper : public MetricsHelperT<CollocatedMetrics>
-{
-public:
+    RemoteInvocationHelper::Attributes RemoteInvocationHelper::attributes;
 
-    class Attributes : public AttributeResolverT<CollocatedInvocationHelper>
+    class CollocatedInvocationHelper : public MetricsHelperT<CollocatedMetrics>
     {
     public:
+        class Attributes : public AttributeResolverT<CollocatedInvocationHelper>
+        {
+        public:
+            Attributes() noexcept
+            {
+                add("parent", &CollocatedInvocationHelper::getParent);
+                add("id", &CollocatedInvocationHelper::getId);
+                add("requestId", &CollocatedInvocationHelper::_requestId);
+            }
+        };
+        static Attributes attributes;
 
-        Attributes()
+        CollocatedInvocationHelper(const Ice::ObjectAdapterPtr& adapter, int requestId, int size)
+            : _requestId(requestId),
+              _size(size),
+              _id(adapter->getName())
         {
-            add("parent", &CollocatedInvocationHelper::getParent);
-            add("id", &CollocatedInvocationHelper::getId);
-            add("requestId", &CollocatedInvocationHelper::_requestId);
         }
-    };
-    static Attributes attributes;
-
-    CollocatedInvocationHelper(const Ice::ObjectAdapterPtr& adapter, int requestId, int size) :
-        _requestId(requestId), _size(size), _id(adapter->getName())
-    {
-    }
-
-    virtual string operator()(const string& attribute) const
-    {
-        return attributes(this, attribute);
-    }
 
-    virtual void initMetrics(const CollocatedMetricsPtr& v) const
-    {
-        v->size += _size;
-    }
+        string operator()(const string& attribute) const override { return attributes(this, attribute); }
 
-    const string&
-    getId() const
-    {
-        return _id;
-    }
+        void initMetrics(const CollocatedMetricsPtr& v) const override { v->size += _size; }
 
-    string
-    getParent() const
-    {
-        return "Communicator";
-    }
+        [[nodiscard]] const string& getId() const { return _id; }
 
-protected:
-    //
-    // COMPILERFIX: Clang 4.2 reports unused-private-field for the _requestId
-    // field that is only used in the nested Attributes class.
-    //
-    const int _requestId;
+        [[nodiscard]] string getParent() const { return "Communicator"; }
 
-private:
+    protected:
+        //
+        // COMPILERFIX: Clang 4.2 reports unused-private-field for the _requestId
+        // field that is only used in the nested Attributes class.
+        //
+        const int _requestId;
 
-    const int _size;
-    mutable string _id;
-};
-
-CollocatedInvocationHelper::Attributes CollocatedInvocationHelper::attributes;
+    private:
+        const int _size;
+        mutable string _id;
+    };
 
-class ThreadHelper : public MetricsHelperT<ThreadMetrics>
-{
-public:
+    CollocatedInvocationHelper::Attributes CollocatedInvocationHelper::attributes;
 
-    class Attributes : public AttributeResolverT<ThreadHelper>
+    class ThreadHelper : public MetricsHelperT<ThreadMetrics>
     {
     public:
+        class Attributes : public AttributeResolverT<ThreadHelper>
+        {
+        public:
+            Attributes() noexcept
+            {
+                add("parent", &ThreadHelper::_parent);
+                add("id", &ThreadHelper::_id);
+            }
+        };
+        static Attributes attributes;
 
-        Attributes()
+        ThreadHelper(string parent, string id, ThreadState state)
+            : _parent(std::move(parent)),
+              _id(std::move(id)),
+              _state(state)
         {
-            add("parent", &ThreadHelper::_parent);
-            add("id", &ThreadHelper::_id);
         }
-    };
-    static Attributes attributes;
 
-    ThreadHelper(const string& parent, const string& id, ThreadState state) : _parent(parent), _id(id), _state(state)
-    {
-    }
-
-    virtual string operator()(const string& attribute) const
-    {
-        return attributes(this, attribute);
-    }
+        string operator()(const string& attribute) const override { return attributes(this, attribute); }
 
-    virtual void initMetrics(const ThreadMetricsPtr& v) const
-    {
-        if(_state != ICE_ENUM(ThreadState, ThreadStateIdle))
+        void initMetrics(const ThreadMetricsPtr& v) const override
         {
-            ++(v.get()->*getThreadStateMetric(_state));
+            if (_state != ThreadState::ThreadStateIdle)
+            {
+                ++(v.get()->*getThreadStateMetric(_state));
+            }
         }
-    }
 
-private:
-
-    const string _parent;
-    const string _id;
-    const ThreadState _state;
-};
-
-ThreadHelper::Attributes ThreadHelper::attributes;
+    private:
+        const string _parent;
+        const string _id;
+        const ThreadState _state;
+    };
 
-class EndpointHelper : public MetricsHelperT<Metrics>
-{
-public:
+    ThreadHelper::Attributes ThreadHelper::attributes;
 
-    class Attributes : public AttributeResolverT<EndpointHelper>
+    class EndpointHelper : public MetricsHelperT<Metrics>
     {
     public:
-
-        Attributes()
+        class Attributes : public AttributeResolverT<EndpointHelper>
         {
-            add("parent", &EndpointHelper::getParent);
-            add("id", &EndpointHelper::getId);
-            addEndpointAttributes<EndpointHelper>(*this);
-        }
-    };
-    static Attributes attributes;
+        public:
+            Attributes() noexcept
+            {
+                add("parent", &EndpointHelper::getParent);
+                add("id", &EndpointHelper::getId);
+                addEndpointAttributes<EndpointHelper>(*this);
+            }
+        };
+        static Attributes attributes;
 
-    EndpointHelper(const EndpointPtr& endpt, const string& id) : _endpoint(endpt), _id(id)
-    {
-    }
+        EndpointHelper(EndpointPtr endpt, string id) : _endpoint(std::move(endpt)), _id(std::move(id)) {}
 
-    EndpointHelper(const EndpointPtr& endpt) : _endpoint(endpt)
-    {
-    }
+        EndpointHelper(EndpointPtr endpt) : _endpoint(std::move(endpt)) {}
 
-    virtual string operator()(const string& attribute) const
-    {
-        return attributes(this, attribute);
-    }
+        string operator()(const string& attribute) const override { return attributes(this, attribute); }
 
-    const EndpointInfoPtr&
-    getEndpointInfo() const
-    {
-        if(!_endpointInfo)
+        [[nodiscard]] const EndpointInfoPtr& getEndpointInfo() const
         {
-            _endpointInfo = _endpoint->getInfo();
+            if (!_endpointInfo)
+            {
+                _endpointInfo = _endpoint->getInfo();
+            }
+            return _endpointInfo;
         }
-        return _endpointInfo;
-    }
 
-    string
-    getParent() const
-    {
-        return "Communicator";
-    }
+        [[nodiscard]] string getParent() const { return "Communicator"; }
 
-    const string&
-    getId() const
-    {
-        if(_id.empty())
+        [[nodiscard]] const string& getId() const
         {
-            _id = _endpoint->toString();
+            if (_id.empty())
+            {
+                _id = _endpoint->toString();
+            }
+            return _id;
         }
-        return _id;
-    }
 
-    string
-    getEndpoint() const
-    {
-        return _endpoint->toString();
-    }
+        [[nodiscard]] string getEndpoint() const { return _endpoint->toString(); }
 
-private:
-
-    const EndpointPtr _endpoint;
-    mutable string _id;
-    mutable EndpointInfoPtr _endpointInfo;
-};
-
-EndpointHelper::Attributes EndpointHelper::attributes;
+    private:
+        const EndpointPtr _endpoint;
+        mutable string _id;
+        mutable EndpointInfoPtr _endpointInfo;
+    };
 
+    EndpointHelper::Attributes EndpointHelper::attributes;
 }
 
 void
-ConnectionObserverI::sentBytes(Int num)
+ConnectionObserverI::sentBytes(int32_t num)
 {
     forEach(add(&ConnectionMetrics::sentBytes, num));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->sentBytes(num);
     }
 }
 
 void
-ConnectionObserverI::receivedBytes(Int num)
+ConnectionObserverI::receivedBytes(int32_t num)
 {
     forEach(add(&ConnectionMetrics::receivedBytes, num));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->receivedBytes(num);
     }
@@ -792,48 +653,47 @@ void
 ThreadObserverI::stateChanged(ThreadState oldState, ThreadState newState)
 {
     forEach(ThreadStateChanged(oldState, newState));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->stateChanged(oldState, newState);
     }
-
 }
 
 void
 DispatchObserverI::userException()
 {
     forEach(inc(&DispatchMetrics::userException));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->userException();
     }
 }
 
 void
-DispatchObserverI::reply(Int size)
+DispatchObserverI::reply(int32_t size)
 {
     forEach(add(&DispatchMetrics::replySize, size));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->reply(size);
     }
 }
 
 void
-RemoteObserverI::reply(Int size)
+RemoteObserverI::reply(int32_t size)
 {
     forEach(add(&RemoteMetrics::replySize, size));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->reply(size);
     }
 }
 
 void
-CollocatedObserverI::reply(Int size)
+CollocatedObserverI::reply(int32_t size)
 {
     forEach(add(&CollocatedMetrics::replySize, size));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->reply(size);
     }
@@ -843,7 +703,7 @@ void
 InvocationObserverI::retried()
 {
     forEach(inc(&InvocationMetrics::retry));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->retried();
     }
@@ -853,33 +713,35 @@ void
 InvocationObserverI::userException()
 {
     forEach(inc(&InvocationMetrics::userException));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->userException();
     }
 }
 
 RemoteObserverPtr
-InvocationObserverI::getRemoteObserver(const ConnectionInfoPtr& connection,
-                                       const EndpointPtr& endpoint,
-                                       int requestId,
-                                       int size)
+InvocationObserverI::getRemoteObserver(
+    const ConnectionInfoPtr& connection,
+    const EndpointPtr& endpoint,
+    int requestId,
+    int size)
 {
     try
     {
         RemoteObserverPtr delegate;
-        if(_delegate)
+        if (_delegate)
         {
             delegate = _delegate->getRemoteObserver(connection, endpoint, requestId, size);
         }
-        return getObserverWithDelegate<RemoteObserverI>("Remote",
-                                                        RemoteInvocationHelper(connection, endpoint, requestId, size),
-                                                        delegate);
+        return getObserverWithDelegate<RemoteObserverI>(
+            "Remote",
+            RemoteInvocationHelper(connection, endpoint, requestId, size),
+            delegate);
     }
-    catch(const exception&)
+    catch (const exception&)
     {
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 CollocatedObserverPtr
@@ -888,29 +750,30 @@ InvocationObserverI::getCollocatedObserver(const Ice::ObjectAdapterPtr& adapter,
     try
     {
         CollocatedObserverPtr delegate;
-        if(_delegate)
+        if (_delegate)
         {
             delegate = _delegate->getCollocatedObserver(adapter, requestId, size);
         }
-        return getObserverWithDelegate<CollocatedObserverI>("Collocated",
-                                                            CollocatedInvocationHelper(adapter, requestId, size),
-                                                            delegate);
+        return getObserverWithDelegate<CollocatedObserverI>(
+            "Collocated",
+            CollocatedInvocationHelper(adapter, requestId, size),
+            delegate);
     }
-    catch(const exception&)
+    catch (const exception&)
     {
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
-CommunicatorObserverI::CommunicatorObserverI(const InitializationData& initData) :
-    _metrics(new MetricsAdminI(initData.properties, initData.logger)),
-    _delegate(initData.observer),
-    _connections(_metrics, "Connection"),
-    _dispatch(_metrics, "Dispatch"),
-    _invocations(_metrics, "Invocation"),
-    _threads(_metrics, "Thread"),
-    _connects(_metrics, "ConnectionEstablishment"),
-    _endpointLookups(_metrics, "EndpointLookup")
+CommunicatorObserverI::CommunicatorObserverI(const InitializationData& initData)
+    : _metrics(new MetricsAdminI(initData.properties, initData.logger)),
+      _delegate(initData.observer),
+      _connections(_metrics, "Connection"),
+      _dispatch(_metrics, "Dispatch"),
+      _invocations(_metrics, "Invocation"),
+      _threads(_metrics, "Thread"),
+      _connects(_metrics, "ConnectionEstablishment"),
+      _endpointLookups(_metrics, "EndpointLookup")
 {
     _invocations.registerSubMap<RemoteMetrics>("Remote", &InvocationMetrics::remotes);
     _invocations.registerSubMap<CollocatedMetrics>("Collocated", &InvocationMetrics::collocated);
@@ -921,7 +784,7 @@ CommunicatorObserverI::setObserverUpdater(const ObserverUpdaterPtr& updater)
 {
     _connections.setUpdater(newUpdater(updater, &ObserverUpdater::updateConnectionObservers));
     _threads.setUpdater(newUpdater(updater, &ObserverUpdater::updateThreadObservers));
-    if(_delegate)
+    if (_delegate)
     {
         _delegate->setObserverUpdater(updater);
     }
@@ -930,147 +793,149 @@ CommunicatorObserverI::setObserverUpdater(const ObserverUpdaterPtr& updater)
 ObserverPtr
 CommunicatorObserverI::getConnectionEstablishmentObserver(const EndpointPtr& endpt, const string& connector)
 {
-    if(_connects.isEnabled())
+    if (_connects.isEnabled())
     {
         try
         {
             ObserverPtr delegate;
-            if(_delegate)
+            if (_delegate)
             {
                 delegate = _delegate->getConnectionEstablishmentObserver(endpt, connector);
             }
             return _connects.getObserverWithDelegate(EndpointHelper(endpt, connector), delegate);
         }
-        catch(const exception& ex)
+        catch (const exception& ex)
         {
             Error error(_metrics->getLogger());
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 ObserverPtr
 CommunicatorObserverI::getEndpointLookupObserver(const EndpointPtr& endpt)
 {
-    if(_endpointLookups.isEnabled())
+    if (_endpointLookups.isEnabled())
     {
         try
         {
             ObserverPtr delegate;
-            if(_delegate)
+            if (_delegate)
             {
                 delegate = _delegate->getEndpointLookupObserver(endpt);
             }
             return _endpointLookups.getObserverWithDelegate(EndpointHelper(endpt), delegate);
         }
-        catch(const exception& ex)
+        catch (const exception& ex)
         {
             Error error(_metrics->getLogger());
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 ConnectionObserverPtr
-CommunicatorObserverI::getConnectionObserver(const ConnectionInfoPtr& con,
-                                             const EndpointPtr& endpt,
-                                             ConnectionState state,
-                                             const ConnectionObserverPtr& observer)
+CommunicatorObserverI::getConnectionObserver(
+    const ConnectionInfoPtr& con,
+    const EndpointPtr& endpt,
+    ConnectionState state,
+    const ConnectionObserverPtr& observer)
 {
-    if(_connections.isEnabled())
+    if (_connections.isEnabled())
     {
         try
         {
             ConnectionObserverPtr delegate;
-            ConnectionObserverI* o = dynamic_cast<ConnectionObserverI*>(observer.get());
-            if(_delegate)
+            auto o = dynamic_pointer_cast<ConnectionObserverI>(observer);
+            if (_delegate)
             {
                 delegate = _delegate->getConnectionObserver(con, endpt, state, o ? o->getDelegate() : observer);
             }
             return _connections.getObserverWithDelegate(ConnectionHelper(con, endpt, state), delegate, observer);
         }
-        catch(const exception& ex)
+        catch (const exception& ex)
         {
             Error error(_metrics->getLogger());
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 ThreadObserverPtr
-CommunicatorObserverI::getThreadObserver(const string& parent,
-                                         const string& id,
-                                         ThreadState state,
-                                         const ThreadObserverPtr& observer)
+CommunicatorObserverI::getThreadObserver(
+    const string& parent,
+    const string& id,
+    ThreadState state,
+    const ThreadObserverPtr& observer)
 {
-    if(_threads.isEnabled())
+    if (_threads.isEnabled())
     {
         try
         {
             ThreadObserverPtr delegate;
-            ThreadObserverI* o = dynamic_cast<ThreadObserverI*>(observer.get());
-            if(_delegate)
+            auto o = dynamic_pointer_cast<ThreadObserverI>(observer);
+            if (_delegate)
             {
                 delegate = _delegate->getThreadObserver(parent, id, state, o ? o->getDelegate() : observer);
             }
             return _threads.getObserverWithDelegate(ThreadHelper(parent, id, state), delegate, observer);
         }
-        catch(const exception& ex)
+        catch (const exception& ex)
         {
             Error error(_metrics->getLogger());
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 InvocationObserverPtr
-CommunicatorObserverI::getInvocationObserver(const ObjectPrxPtr& proxy, const string& op, const Context& ctx)
+CommunicatorObserverI::getInvocationObserver(const optional<ObjectPrx>& proxy, string_view op, const Context& ctx)
 {
-    if(_invocations.isEnabled())
+    if (_invocations.isEnabled())
     {
         try
         {
             InvocationObserverPtr delegate;
-            if(_delegate)
+            if (_delegate)
             {
                 delegate = _delegate->getInvocationObserver(proxy, op, ctx);
             }
             return _invocations.getObserverWithDelegate(InvocationHelper(proxy, op, ctx), delegate);
         }
-        catch(const exception& ex)
+        catch (const exception& ex)
         {
             Error error(_metrics->getLogger());
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 DispatchObserverPtr
 CommunicatorObserverI::getDispatchObserver(const Current& current, int size)
 {
-    if(_dispatch.isEnabled())
+    if (_dispatch.isEnabled())
     {
         try
         {
             DispatchObserverPtr delegate;
-            if(_delegate)
+            if (_delegate)
             {
                 delegate = _delegate->getDispatchObserver(current, size);
             }
             return _dispatch.getObserverWithDelegate(DispatchHelper(current, size), delegate);
         }
-        catch(const exception& ex)
+        catch (const exception& ex)
         {
             Error error(_metrics->getLogger());
             error << "unexpected exception trying to obtain observer:\n" << ex;
         }
     }
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 const IceInternal::MetricsAdminIPtr&