zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/generated/Metrics.cpp

@@ -1,616 +1,437 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-//
-// Ice version 3.7.11
-//
-// <auto-generated>
-//
-// Generated from file `Metrics.ice'
-//
-// Warning: do not edit this file.
-//
-// </auto-generated>
-//
+// Copyright (c) ZeroC, Inc.
+
+// slice2cpp version 3.8.1
+// <auto-generated>Generated from Slice file 'Metrics.ice'.</auto-generated>
 
 #ifndef ICE_API_EXPORTS
 #   define ICE_API_EXPORTS
 #endif
-#include <Ice/Metrics.h>
-#include <IceUtil/PushDisableWarnings.h>
-#include <Ice/LocalException.h>
-#include <Ice/ValueFactory.h>
+#define ICE_BUILDING_GENERATED_CODE
+
+#include "Ice/Metrics.h"
+#include <Ice/AsyncResponseHandler.h>
+#include <Ice/DefaultSliceLoader.h>
 #include <Ice/OutgoingAsync.h>
-#include <Ice/InputStream.h>
-#include <Ice/OutputStream.h>
-#include <Ice/LocalException.h>
-#include <IceUtil/PopDisableWarnings.h>
+#include <algorithm>
+#include <array>
 
 #if defined(_MSC_VER)
-#   pragma warning(disable:4458) // declaration of ... hides class member
+#   pragma warning(disable : 4458) // declaration of ... hides class member
+#   pragma warning(disable : 4996) // ... was declared deprecated
 #elif defined(__clang__)
 #   pragma clang diagnostic ignored "-Wshadow"
+#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #elif defined(__GNUC__)
 #   pragma GCC diagnostic ignored "-Wshadow"
+#   pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-#ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 307
+#ifndef ICE_DISABLE_VERSION
+#   if ICE_INT_VERSION / 100 != 308
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 11
+#   if ICE_INT_VERSION % 100 < 1
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-
 namespace
 {
-
-const ::IceInternal::DefaultValueFactoryInit<::IceMX::Metrics> iceC_IceMX_Metrics_init("::IceMX::Metrics");
-
-const ::IceInternal::DefaultUserExceptionFactoryInit<::IceMX::UnknownMetricsView> iceC_IceMX_UnknownMetricsView_init("::IceMX::UnknownMetricsView");
-
-const ::std::string iceC_IceMX_MetricsAdmin_ids[2] =
-{
-    "::Ice::Object",
-    "::IceMX::MetricsAdmin"
-};
-const ::std::string iceC_IceMX_MetricsAdmin_ops[] =
-{
-    "disableMetricsView",
-    "enableMetricsView",
-    "getMapMetricsFailures",
-    "getMetricsFailures",
-    "getMetricsView",
-    "getMetricsViewNames",
-    "ice_id",
-    "ice_ids",
-    "ice_isA",
-    "ice_ping"
-};
-const ::std::string iceC_IceMX_MetricsAdmin_getMetricsViewNames_name = "getMetricsViewNames";
-const ::std::string iceC_IceMX_MetricsAdmin_enableMetricsView_name = "enableMetricsView";
-const ::std::string iceC_IceMX_MetricsAdmin_disableMetricsView_name = "disableMetricsView";
-const ::std::string iceC_IceMX_MetricsAdmin_getMetricsView_name = "getMetricsView";
-const ::std::string iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name = "getMapMetricsFailures";
-const ::std::string iceC_IceMX_MetricsAdmin_getMetricsFailures_name = "getMetricsFailures";
-
-const ::IceInternal::DefaultValueFactoryInit<::IceMX::ThreadMetrics> iceC_IceMX_ThreadMetrics_init("::IceMX::ThreadMetrics");
-
-const ::IceInternal::DefaultValueFactoryInit<::IceMX::DispatchMetrics> iceC_IceMX_DispatchMetrics_init("::IceMX::DispatchMetrics");
-
-const ::IceInternal::DefaultValueFactoryInit<::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");
-
-const ::IceInternal::DefaultValueFactoryInit<::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init("::IceMX::CollocatedMetrics");
-
-const ::IceInternal::DefaultValueFactoryInit<::IceMX::RemoteMetrics> iceC_IceMX_RemoteMetrics_init("::IceMX::RemoteMetrics");
-
-const ::IceInternal::DefaultValueFactoryInit<::IceMX::InvocationMetrics> iceC_IceMX_InvocationMetrics_init("::IceMX::InvocationMetrics");
-
-const ::IceInternal::DefaultValueFactoryInit<::IceMX::ConnectionMetrics> iceC_IceMX_ConnectionMetrics_init("::IceMX::ConnectionMetrics");
-
-}
-
-IceMX::UnknownMetricsView::~UnknownMetricsView()
-{
-}
-
-const ::std::string&
-IceMX::UnknownMetricsView::ice_staticId()
-{
-    static const ::std::string typeId = "::IceMX::UnknownMetricsView";
-    return typeId;
-}
-
-bool
-IceMX::MetricsAdmin::ice_isA(::std::string s, const ::Ice::Current&) const
-{
-    return ::std::binary_search(iceC_IceMX_MetricsAdmin_ids, iceC_IceMX_MetricsAdmin_ids + 2, s);
-}
-
-::std::vector<::std::string>
-IceMX::MetricsAdmin::ice_ids(const ::Ice::Current&) const
-{
-    return ::std::vector<::std::string>(&iceC_IceMX_MetricsAdmin_ids[0], &iceC_IceMX_MetricsAdmin_ids[2]);
-}
-
-::std::string
-IceMX::MetricsAdmin::ice_id(const ::Ice::Current&) const
-{
-    return ice_staticId();
-}
-
-const ::std::string&
-IceMX::MetricsAdmin::ice_staticId()
-{
-    static const ::std::string typeId = "::IceMX::MetricsAdmin";
-    return typeId;
+    const IceInternal::ClassInit<::IceMX::Metrics> iceC_IceMX_Metrics_init;
+    const IceInternal::ExceptionInit<::IceMX::UnknownMetricsView> iceC_IceMX_UnknownMetricsView_init;
+    const IceInternal::ClassInit<::IceMX::ThreadMetrics> iceC_IceMX_ThreadMetrics_init;
+    const IceInternal::ClassInit<::IceMX::DispatchMetrics> iceC_IceMX_DispatchMetrics_init;
+    const IceInternal::ClassInit<::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init;
+    const IceInternal::ClassInit<::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init;
+    const IceInternal::ClassInit<::IceMX::RemoteMetrics> iceC_IceMX_RemoteMetrics_init;
+    const IceInternal::ClassInit<::IceMX::InvocationMetrics> iceC_IceMX_InvocationMetrics_init;
+    const IceInternal::ClassInit<::IceMX::ConnectionMetrics> iceC_IceMX_ConnectionMetrics_init;
 }
 
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
-    inS.readEmptyParams();
-    inS.setFormat(::Ice::FormatType::SlicedFormat);
-    ::Ice::StringSeq iceP_disabledViews;
-    ::Ice::StringSeq ret = this->getMetricsViewNames(iceP_disabledViews, current);
-    auto ostr = inS.startWriteParams();
-    ostr->writeAll(iceP_disabledViews, ret);
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
+IceMX::MetricsAdminPrx::~MetricsAdminPrx() = default;
 
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+::Ice::StringSeq
+IceMX::MetricsAdminPrx::getMetricsViewNames(::Ice::StringSeq& iceP_disabledViews, const Ice::Context& context) const
 {
-    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
-    auto istr = inS.startReadParams();
-    ::std::string iceP_name;
-    istr->readAll(iceP_name);
-    inS.endReadParams();
-    inS.setFormat(::Ice::FormatType::SlicedFormat);
-    this->enableMetricsView(::std::move(iceP_name), current);
-    inS.writeEmptyParams();
-    return true;
+    auto result = IceInternal::makePromiseOutgoing<std::tuple<::Ice::StringSeq, ::Ice::StringSeq>>(true, this, &MetricsAdminPrx::_iceI_getMetricsViewNames, context).get();
+    iceP_disabledViews = std::move(std::get<1>(result));
+    return std::move(std::get<0>(result));
 }
-/// \endcond
 
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+std::future<std::tuple<::Ice::StringSeq, ::Ice::StringSeq>>
+IceMX::MetricsAdminPrx::getMetricsViewNamesAsync(const Ice::Context& context) const
 {
-    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
-    auto istr = inS.startReadParams();
-    ::std::string iceP_name;
-    istr->readAll(iceP_name);
-    inS.endReadParams();
-    inS.setFormat(::Ice::FormatType::SlicedFormat);
-    this->disableMetricsView(::std::move(iceP_name), current);
-    inS.writeEmptyParams();
-    return true;
+    return IceInternal::makePromiseOutgoing<std::tuple<::Ice::StringSeq, ::Ice::StringSeq>>(false, this, &MetricsAdminPrx::_iceI_getMetricsViewNames, context);
 }
-/// \endcond
 
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
+std::function<void()>
+IceMX::MetricsAdminPrx::getMetricsViewNamesAsync(std::function<void(::Ice::StringSeq, ::Ice::StringSeq)> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
 {
-    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
-    auto istr = inS.startReadParams();
-    ::std::string iceP_view;
-    istr->readAll(iceP_view);
-    inS.endReadParams();
-    inS.setFormat(::Ice::FormatType::SlicedFormat);
-    long long int iceP_timestamp;
-    MetricsView ret = this->getMetricsView(::std::move(iceP_view), iceP_timestamp, current);
-    auto ostr = inS.startWriteParams();
-    ostr->writeAll(iceP_timestamp, ret);
-    ostr->writePendingValues();
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
-    auto istr = inS.startReadParams();
-    ::std::string iceP_view;
-    ::std::string iceP_map;
-    istr->readAll(iceP_view, iceP_map);
-    inS.endReadParams();
-    inS.setFormat(::Ice::FormatType::SlicedFormat);
-    MetricsFailuresSeq ret = this->getMapMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), current);
-    auto ostr = inS.startWriteParams();
-    ostr->writeAll(ret);
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_getMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
-    auto istr = inS.startReadParams();
-    ::std::string iceP_view;
-    ::std::string iceP_map;
-    ::std::string iceP_id;
-    istr->readAll(iceP_view, iceP_map, iceP_id);
-    inS.endReadParams();
-    inS.setFormat(::Ice::FormatType::SlicedFormat);
-    MetricsFailures ret = this->getMetricsFailures(::std::move(iceP_view), ::std::move(iceP_map), ::std::move(iceP_id), current);
-    auto ostr = inS.startWriteParams();
-    ostr->writeAll(ret);
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
-{
-    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceMX_MetricsAdmin_ops, iceC_IceMX_MetricsAdmin_ops + 10, current.operation);
-    if(r.first == r.second)
+    auto responseCb = [response = std::move(response)](std::tuple<::Ice::StringSeq, ::Ice::StringSeq>&& result) mutable
     {
-        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
-    }
-
-    switch(r.first - iceC_IceMX_MetricsAdmin_ops)
-    {
-        case 0:
-        {
-            return _iceD_disableMetricsView(in, current);
-        }
-        case 1:
-        {
-            return _iceD_enableMetricsView(in, current);
-        }
-        case 2:
-        {
-            return _iceD_getMapMetricsFailures(in, current);
-        }
-        case 3:
-        {
-            return _iceD_getMetricsFailures(in, current);
-        }
-        case 4:
-        {
-            return _iceD_getMetricsView(in, current);
-        }
-        case 5:
-        {
-            return _iceD_getMetricsViewNames(in, current);
-        }
-        case 6:
-        {
-            return _iceD_ice_id(in, current);
-        }
-        case 7:
-        {
-            return _iceD_ice_ids(in, current);
-        }
-        case 8:
-        {
-            return _iceD_ice_isA(in, current);
-        }
-        case 9:
-        {
-            return _iceD_ice_ping(in, current);
-        }
-        default:
-        {
-            assert(false);
-            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
-        }
-    }
-}
-/// \endcond
-
-IceMX::Metrics::~Metrics()
-{
-}
-
-const ::std::string&
-IceMX::Metrics::ice_staticId()
-{
-    static const ::std::string typeId = "::IceMX::Metrics";
-    return typeId;
-}
-
-IceMX::ThreadMetrics::~ThreadMetrics()
-{
-}
-
-const ::std::string&
-IceMX::ThreadMetrics::ice_staticId()
-{
-    static const ::std::string typeId = "::IceMX::ThreadMetrics";
-    return typeId;
-}
-
-IceMX::DispatchMetrics::~DispatchMetrics()
-{
-}
-
-const ::std::string&
-IceMX::DispatchMetrics::ice_staticId()
-{
-    static const ::std::string typeId = "::IceMX::DispatchMetrics";
-    return typeId;
-}
-
-IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
-{
-}
-
-const ::std::string&
-IceMX::ChildInvocationMetrics::ice_staticId()
-{
-    static const ::std::string typeId = "::IceMX::ChildInvocationMetrics";
-    return typeId;
-}
-
-IceMX::CollocatedMetrics::~CollocatedMetrics()
-{
-}
-
-const ::std::string&
-IceMX::CollocatedMetrics::ice_staticId()
-{
-    static const ::std::string typeId = "::IceMX::CollocatedMetrics";
-    return typeId;
+        std::apply(std::move(response), std::move(result));
+    };
+    return IceInternal::makeLambdaOutgoing<std::tuple<::Ice::StringSeq, ::Ice::StringSeq>>(std::move(responseCb), std::move(exception), std::move(sent), this, &IceMX::MetricsAdminPrx::_iceI_getMetricsViewNames, context);
 }
 
-IceMX::RemoteMetrics::~RemoteMetrics()
-{
-}
-
-const ::std::string&
-IceMX::RemoteMetrics::ice_staticId()
+void
+IceMX::MetricsAdminPrx::_iceI_getMetricsViewNames(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::tuple<::Ice::StringSeq, ::Ice::StringSeq>>>& outAsync, const Ice::Context& context) const
 {
-    static const ::std::string typeId = "::IceMX::RemoteMetrics";
-    return typeId;
-}
+    static constexpr std::string_view operationName = "getMetricsViewNames";
 
-IceMX::InvocationMetrics::~InvocationMetrics()
-{
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Normal,
+        std::nullopt,
+        context,
+        nullptr,
+        nullptr,
+        [](Ice::InputStream* istr)
+        {
+            std::tuple<::Ice::StringSeq, ::Ice::StringSeq> v;
+            istr->readAll(std::get<1>(v), std::get<0>(v));
+            return v;
+        });
 }
 
-const ::std::string&
-IceMX::InvocationMetrics::ice_staticId()
+void
+IceMX::MetricsAdminPrx::enableMetricsView(std::string_view iceP_name, const Ice::Context& context) const
 {
-    static const ::std::string typeId = "::IceMX::InvocationMetrics";
-    return typeId;
+    IceInternal::makePromiseOutgoing<void>(true, this, &MetricsAdminPrx::_iceI_enableMetricsView, iceP_name, context).get();
 }
 
-IceMX::ConnectionMetrics::~ConnectionMetrics()
+std::future<void>
+IceMX::MetricsAdminPrx::enableMetricsViewAsync(std::string_view iceP_name, const Ice::Context& context) const
 {
+    return IceInternal::makePromiseOutgoing<void>(false, this, &MetricsAdminPrx::_iceI_enableMetricsView, iceP_name, context);
 }
 
-const ::std::string&
-IceMX::ConnectionMetrics::ice_staticId()
+std::function<void()>
+IceMX::MetricsAdminPrx::enableMetricsViewAsync(std::string_view iceP_name, std::function<void()> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
 {
-    static const ::std::string typeId = "::IceMX::ConnectionMetrics";
-    return typeId;
+    return IceInternal::makeLambdaOutgoing<void>(std::move(response), std::move(exception), std::move(sent), this, &IceMX::MetricsAdminPrx::_iceI_enableMetricsView, iceP_name, context);
 }
 
-/// \cond INTERNAL
 void
-IceMX::MetricsAdminPrx::_iceI_getMetricsViewNames(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<MetricsAdmin::GetMetricsViewNamesResult>>& outAsync, const ::Ice::Context& context)
+IceMX::MetricsAdminPrx::_iceI_enableMetricsView(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, std::string_view iceP_name, const Ice::Context& context) const
 {
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
-    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
-        nullptr,
-        nullptr,
-        [](::Ice::InputStream* istr)
-        {
-            MetricsAdmin::GetMetricsViewNamesResult v;
-            istr->readAll(v.disabledViews, v.returnValue);
-            return v;
-        });
-}
-/// \endcond
+    static constexpr std::string_view operationName = "enableMetricsView";
 
-/// \cond INTERNAL
-void
-IceMX::MetricsAdminPrx::_iceI_enableMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_name, const ::Ice::Context& context)
-{
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_enableMetricsView_name);
-    outAsync->invoke(iceC_IceMX_MetricsAdmin_enableMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Normal,
+        std::nullopt,
+        context,
+        [&](Ice::OutputStream* ostr)
         {
             ostr->writeAll(iceP_name);
         },
-        [](const ::Ice::UserException& ex)
+        [](const Ice::UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const UnknownMetricsView&)
+            catch (const UnknownMetricsView&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch (const Ice::UserException&)
             {
             }
         });
 }
-/// \endcond
 
-/// \cond INTERNAL
 void
-IceMX::MetricsAdminPrx::_iceI_disableMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::std::string& iceP_name, const ::Ice::Context& context)
+IceMX::MetricsAdminPrx::disableMetricsView(std::string_view iceP_name, const Ice::Context& context) const
+{
+    IceInternal::makePromiseOutgoing<void>(true, this, &MetricsAdminPrx::_iceI_disableMetricsView, iceP_name, context).get();
+}
+
+std::future<void>
+IceMX::MetricsAdminPrx::disableMetricsViewAsync(std::string_view iceP_name, const Ice::Context& context) const
+{
+    return IceInternal::makePromiseOutgoing<void>(false, this, &MetricsAdminPrx::_iceI_disableMetricsView, iceP_name, context);
+}
+
+std::function<void()>
+IceMX::MetricsAdminPrx::disableMetricsViewAsync(std::string_view iceP_name, std::function<void()> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
+{
+    return IceInternal::makeLambdaOutgoing<void>(std::move(response), std::move(exception), std::move(sent), this, &IceMX::MetricsAdminPrx::_iceI_disableMetricsView, iceP_name, context);
+}
+
+void
+IceMX::MetricsAdminPrx::_iceI_disableMetricsView(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, std::string_view iceP_name, const Ice::Context& context) const
 {
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_disableMetricsView_name);
-    outAsync->invoke(iceC_IceMX_MetricsAdmin_disableMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    static constexpr std::string_view operationName = "disableMetricsView";
+
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Normal,
+        std::nullopt,
+        context,
+        [&](Ice::OutputStream* ostr)
         {
             ostr->writeAll(iceP_name);
         },
-        [](const ::Ice::UserException& ex)
+        [](const Ice::UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const UnknownMetricsView&)
+            catch (const UnknownMetricsView&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch (const Ice::UserException&)
             {
             }
         });
 }
-/// \endcond
 
-/// \cond INTERNAL
+::IceMX::MetricsView
+IceMX::MetricsAdminPrx::getMetricsView(std::string_view iceP_view, std::int64_t& iceP_timestamp, const Ice::Context& context) const
+{
+    auto result = IceInternal::makePromiseOutgoing<std::tuple<MetricsView, std::int64_t>>(true, this, &MetricsAdminPrx::_iceI_getMetricsView, iceP_view, context).get();
+    iceP_timestamp = std::get<1>(result);
+    return std::move(std::get<0>(result));
+}
+
+std::future<std::tuple<::IceMX::MetricsView, std::int64_t>>
+IceMX::MetricsAdminPrx::getMetricsViewAsync(std::string_view iceP_view, const Ice::Context& context) const
+{
+    return IceInternal::makePromiseOutgoing<std::tuple<MetricsView, std::int64_t>>(false, this, &MetricsAdminPrx::_iceI_getMetricsView, iceP_view, context);
+}
+
+std::function<void()>
+IceMX::MetricsAdminPrx::getMetricsViewAsync(std::string_view iceP_view, std::function<void(::IceMX::MetricsView, std::int64_t)> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
+{
+    auto responseCb = [response = std::move(response)](std::tuple<MetricsView, std::int64_t>&& result) mutable
+    {
+        std::apply(std::move(response), std::move(result));
+    };
+    return IceInternal::makeLambdaOutgoing<std::tuple<MetricsView, std::int64_t>>(std::move(responseCb), std::move(exception), std::move(sent), this, &IceMX::MetricsAdminPrx::_iceI_getMetricsView, iceP_view, context);
+}
+
 void
-IceMX::MetricsAdminPrx::_iceI_getMetricsView(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<MetricsAdmin::GetMetricsViewResult>>& outAsync, const ::std::string& iceP_view, const ::Ice::Context& context)
+IceMX::MetricsAdminPrx::_iceI_getMetricsView(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::tuple<MetricsView, std::int64_t>>>& outAsync, std::string_view iceP_view, const Ice::Context& context) const
 {
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsView_name);
-    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsView_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    static constexpr std::string_view operationName = "getMetricsView";
+
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Normal,
+        Ice::FormatType::SlicedFormat,
+        context,
+        [&](Ice::OutputStream* ostr)
         {
             ostr->writeAll(iceP_view);
         },
-        [](const ::Ice::UserException& ex)
+        [](const Ice::UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const UnknownMetricsView&)
+            catch (const UnknownMetricsView&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch (const Ice::UserException&)
             {
             }
         },
-        [](::Ice::InputStream* istr)
+        [](Ice::InputStream* istr)
         {
-            MetricsAdmin::GetMetricsViewResult v;
-            istr->readAll(v.timestamp, v.returnValue);
+            std::tuple<MetricsView, std::int64_t> v;
+            istr->readAll(std::get<1>(v), std::get<0>(v));
             istr->readPendingValues();
             return v;
         });
 }
-/// \endcond
 
-/// \cond INTERNAL
+::IceMX::MetricsFailuresSeq
+IceMX::MetricsAdminPrx::getMapMetricsFailures(std::string_view iceP_view, std::string_view iceP_map, const Ice::Context& context) const
+{
+    return IceInternal::makePromiseOutgoing<MetricsFailuresSeq>(true, this, &MetricsAdminPrx::_iceI_getMapMetricsFailures, iceP_view, iceP_map, context).get();
+}
+
+std::future<::IceMX::MetricsFailuresSeq>
+IceMX::MetricsAdminPrx::getMapMetricsFailuresAsync(std::string_view iceP_view, std::string_view iceP_map, const Ice::Context& context) const
+{
+    return IceInternal::makePromiseOutgoing<MetricsFailuresSeq>(false, this, &MetricsAdminPrx::_iceI_getMapMetricsFailures, iceP_view, iceP_map, context);
+}
+
+std::function<void()>
+IceMX::MetricsAdminPrx::getMapMetricsFailuresAsync(std::string_view iceP_view, std::string_view iceP_map, std::function<void(::IceMX::MetricsFailuresSeq)> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
+{
+    return IceInternal::makeLambdaOutgoing<MetricsFailuresSeq>(std::move(response), std::move(exception), std::move(sent), this, &IceMX::MetricsAdminPrx::_iceI_getMapMetricsFailures, iceP_view, iceP_map, context);
+}
+
 void
-IceMX::MetricsAdminPrx::_iceI_getMapMetricsFailures(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsFailuresSeq>>& outAsync, const ::std::string& iceP_view, const ::std::string& iceP_map, const ::Ice::Context& context)
+IceMX::MetricsAdminPrx::_iceI_getMapMetricsFailures(const std::shared_ptr<IceInternal::OutgoingAsyncT<MetricsFailuresSeq>>& outAsync, std::string_view iceP_view, std::string_view iceP_map, const Ice::Context& context) const
 {
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
-    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    static constexpr std::string_view operationName = "getMapMetricsFailures";
+
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Normal,
+        std::nullopt,
+        context,
+        [&](Ice::OutputStream* ostr)
         {
             ostr->writeAll(iceP_view, iceP_map);
         },
-        [](const ::Ice::UserException& ex)
+        [](const Ice::UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const UnknownMetricsView&)
+            catch (const UnknownMetricsView&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch (const Ice::UserException&)
             {
             }
         });
 }
-/// \endcond
 
-/// \cond INTERNAL
+::IceMX::MetricsFailures
+IceMX::MetricsAdminPrx::getMetricsFailures(std::string_view iceP_view, std::string_view iceP_map, std::string_view iceP_id, const Ice::Context& context) const
+{
+    return IceInternal::makePromiseOutgoing<MetricsFailures>(true, this, &MetricsAdminPrx::_iceI_getMetricsFailures, iceP_view, iceP_map, iceP_id, context).get();
+}
+
+std::future<::IceMX::MetricsFailures>
+IceMX::MetricsAdminPrx::getMetricsFailuresAsync(std::string_view iceP_view, std::string_view iceP_map, std::string_view iceP_id, const Ice::Context& context) const
+{
+    return IceInternal::makePromiseOutgoing<MetricsFailures>(false, this, &MetricsAdminPrx::_iceI_getMetricsFailures, iceP_view, iceP_map, iceP_id, context);
+}
+
+std::function<void()>
+IceMX::MetricsAdminPrx::getMetricsFailuresAsync(std::string_view iceP_view, std::string_view iceP_map, std::string_view iceP_id, std::function<void(::IceMX::MetricsFailures)> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
+{
+    return IceInternal::makeLambdaOutgoing<MetricsFailures>(std::move(response), std::move(exception), std::move(sent), this, &IceMX::MetricsAdminPrx::_iceI_getMetricsFailures, iceP_view, iceP_map, iceP_id, context);
+}
+
 void
-IceMX::MetricsAdminPrx::_iceI_getMetricsFailures(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceMX::MetricsFailures>>& outAsync, const ::std::string& iceP_view, const ::std::string& iceP_map, const ::std::string& iceP_id, const ::Ice::Context& context)
+IceMX::MetricsAdminPrx::_iceI_getMetricsFailures(const std::shared_ptr<IceInternal::OutgoingAsyncT<MetricsFailures>>& outAsync, std::string_view iceP_view, std::string_view iceP_map, std::string_view iceP_id, const Ice::Context& context) const
 {
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
-    outAsync->invoke(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::SlicedFormat, context,
-        [&](::Ice::OutputStream* ostr)
+    static constexpr std::string_view operationName = "getMetricsFailures";
+
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Normal,
+        std::nullopt,
+        context,
+        [&](Ice::OutputStream* ostr)
         {
             ostr->writeAll(iceP_view, iceP_map, iceP_id);
         },
-        [](const ::Ice::UserException& ex)
+        [](const Ice::UserException& ex)
         {
             try
             {
                 ex.ice_throw();
             }
-            catch(const UnknownMetricsView&)
+            catch (const UnknownMetricsView&)
             {
                 throw;
             }
-            catch(const ::Ice::UserException&)
+            catch (const Ice::UserException&)
             {
             }
         });
 }
-/// \endcond
 
-/// \cond INTERNAL
-::std::shared_ptr<::Ice::ObjectPrx>
-IceMX::MetricsAdminPrx::_newInstance() const
+const char*
+IceMX::MetricsAdminPrx::ice_staticId() noexcept
 {
-    return ::IceInternal::createProxy<MetricsAdminPrx>();
+    return "::IceMX::MetricsAdmin";
 }
-/// \endcond
 
-const ::std::string&
-IceMX::MetricsAdminPrx::ice_staticId()
+const char*
+IceMX::Metrics::ice_staticId() noexcept
 {
-    return MetricsAdmin::ice_staticId();
+    return "::IceMX::Metrics";
 }
 
-namespace Ice
+const char*
+IceMX::Metrics::ice_id() const noexcept
 {
+    return ice_staticId();
 }
 
-#else // C++98 mapping
-
-namespace
+void
+IceMX::Metrics::ice_printFields(std::ostream& os) const
 {
-
-const ::std::string iceC_IceMX_MetricsAdmin_getMetricsViewNames_name = "getMetricsViewNames";
-
-const ::std::string iceC_IceMX_MetricsAdmin_enableMetricsView_name = "enableMetricsView";
-
-const ::std::string iceC_IceMX_MetricsAdmin_disableMetricsView_name = "disableMetricsView";
-
-const ::std::string iceC_IceMX_MetricsAdmin_getMetricsView_name = "getMetricsView";
-
-const ::std::string iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name = "getMapMetricsFailures";
-
-const ::std::string iceC_IceMX_MetricsAdmin_getMetricsFailures_name = "getMetricsFailures";
-
+    Ice::print(os << "id = ", this->id);
+    Ice::print(os << ", total = ", this->total);
+    Ice::print(os << ", current = ", this->current);
+    Ice::print(os << ", totalLifetime = ", this->totalLifetime);
+    Ice::print(os << ", failures = ", this->failures);
 }
 
-namespace
+Ice::ValuePtr
+IceMX::Metrics::_iceCloneImpl() const
 {
+    return CloneEnabler<Metrics>::clone(*this);
+}
 
-const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceMX::UnknownMetricsView> iceC_IceMX_UnknownMetricsView_init("::IceMX::UnknownMetricsView");
+void
+IceMX::Metrics::_iceWriteImpl(Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, true);
+    ostr->writeAll(this->id, this->total, this->current, this->totalLifetime, this->failures);
+    ostr->endSlice();
+}
 
+void
+IceMX::Metrics::_iceReadImpl(Ice::InputStream* istr)
+{
+    istr->startSlice();
+    istr->readAll(this->id, this->total, this->current, this->totalLifetime, this->failures);
+    istr->endSlice();
 }
 
-#ifdef ICE_CPP11_COMPILER
-IceMX::UnknownMetricsView::~UnknownMetricsView()
+void
+IceMX::MetricsFailures::ice_printFields(std::ostream& os) const
 {
+    Ice::print(os << "id = ", this->id);
+    Ice::print(os << ", failures = ", this->failures);
 }
-#else
-IceMX::UnknownMetricsView::~UnknownMetricsView() throw()
+
+std::ostream&
+IceMX::operator<<(std::ostream& os, const ::IceMX::MetricsFailures& value)
 {
+    os << "IceMX::MetricsFailures{";
+    value.ice_printFields(os);
+    os << '}';
+    return os;
 }
-#endif
 
-::std::string
-IceMX::UnknownMetricsView::ice_id() const
+const char*
+IceMX::UnknownMetricsView::ice_staticId() noexcept
 {
     return "::IceMX::UnknownMetricsView";
 }
 
-IceMX::UnknownMetricsView*
-IceMX::UnknownMetricsView::ice_clone() const
+const char*
+IceMX::UnknownMetricsView::ice_id() const noexcept
 {
-    return new UnknownMetricsView(*this);
+    return ice_staticId();
 }
 
 void
@@ -619,1734 +440,766 @@ IceMX::UnknownMetricsView::ice_throw() const
     throw *this;
 }
 
-/// \cond STREAM
 void
-IceMX::UnknownMetricsView::_writeImpl(::Ice::OutputStream* ostr) const
+IceMX::UnknownMetricsView::_writeImpl(Ice::OutputStream* ostr) const
 {
-    ostr->startSlice("::IceMX::UnknownMetricsView", -1, true);
-    ::Ice::StreamWriter< UnknownMetricsView, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->startSlice(ice_staticId(), -1, true);
     ostr->endSlice();
 }
 
 void
-IceMX::UnknownMetricsView::_readImpl(::Ice::InputStream* istr)
+IceMX::UnknownMetricsView::_readImpl(Ice::InputStream* istr)
 {
     istr->startSlice();
-    ::Ice::StreamReader< UnknownMetricsView, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
 }
-/// \endcond
 
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(Metrics* p) { return p; }
+const char*
+IceMX::ThreadMetrics::ice_staticId() noexcept
+{
+    return "::IceMX::ThreadMetrics";
+}
 
-void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< Metrics>& v)
+const char*
+IceMX::ThreadMetrics::ice_id() const noexcept
 {
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new Metrics;
-        v->_copyFrom(proxy);
-    }
+    return ice_staticId();
 }
-/// \endcond
 
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::Metrics::_newInstance() const
+void
+IceMX::ThreadMetrics::ice_printFields(std::ostream& os) const
 {
-    return new Metrics;
+    Metrics::ice_printFields(os);
+    Ice::print(os << ", inUseForIO = ", this->inUseForIO);
+    Ice::print(os << ", inUseForUser = ", this->inUseForUser);
+    Ice::print(os << ", inUseForOther = ", this->inUseForOther);
 }
-/// \endcond
 
-const ::std::string&
-IceProxy::IceMX::Metrics::ice_staticId()
+Ice::ValuePtr
+IceMX::ThreadMetrics::_iceCloneImpl() const
 {
-    return ::IceMX::Metrics::ice_staticId();
+    return CloneEnabler<ThreadMetrics>::clone(*this);
 }
 
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(MetricsAdmin* p) { return p; }
+void
+IceMX::ThreadMetrics::_iceWriteImpl(Ice::OutputStream* ostr) const
+{
+    ostr->startSlice(ice_staticId(), -1, false);
+    ostr->writeAll(this->inUseForIO, this->inUseForUser, this->inUseForOther);
+    ostr->endSlice();
+    Metrics::_iceWriteImpl(ostr);
+}
 
 void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< MetricsAdmin>& v)
+IceMX::ThreadMetrics::_iceReadImpl(Ice::InputStream* istr)
 {
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new MetricsAdmin;
-        v->_copyFrom(proxy);
-    }
+    istr->startSlice();
+    istr->readAll(this->inUseForIO, this->inUseForUser, this->inUseForOther);
+    istr->endSlice();
+    Metrics::_iceReadImpl(istr);
 }
-/// \endcond
 
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsViewNames(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
+const char*
+IceMX::DispatchMetrics::ice_staticId() noexcept
 {
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name, ::Ice::Normal, context);
-        result->writeEmptyParams();
-        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
+    return "::IceMX::DispatchMetrics";
 }
 
-::Ice::StringSeq
-IceProxy::IceMX::MetricsAdmin::end_getMetricsViewNames(::Ice::StringSeq& iceP_disabledViews, const ::Ice::AsyncResultPtr& result)
+const char*
+IceMX::DispatchMetrics::ice_id() const noexcept
 {
-    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
-    ::Ice::StringSeq ret;
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(iceP_disabledViews);
-    istr->read(ret);
-    result->_endReadParams();
-    return ret;
+    return ice_staticId();
 }
 
-void IceProxy::IceMX::MetricsAdmin::_iceI_end_getMetricsViewNames(::Ice::StringSeq& iceP_disabledViews, ::Ice::StringSeq& ret, const ::Ice::AsyncResultPtr& result)
+void
+IceMX::DispatchMetrics::ice_printFields(std::ostream& os) const
 {
-    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsViewNames_name);
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(iceP_disabledViews);
-    istr->read(ret);
-    result->_endReadParams();
+    Metrics::ice_printFields(os);
+    Ice::print(os << ", userException = ", this->userException);
+    Ice::print(os << ", size = ", this->size);
+    Ice::print(os << ", replySize = ", this->replySize);
 }
 
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::_iceI_begin_enableMetricsView(const ::std::string& iceP_name, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
+Ice::ValuePtr
+IceMX::DispatchMetrics::_iceCloneImpl() const
 {
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_enableMetricsView_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_enableMetricsView_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_IceMX_MetricsAdmin_enableMetricsView_name, ::Ice::Normal, context);
-        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
-        ostr->write(iceP_name);
-        result->endWriteParams();
-        result->invoke(iceC_IceMX_MetricsAdmin_enableMetricsView_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
+    return CloneEnabler<DispatchMetrics>::clone(*this);
 }
 
 void
-IceProxy::IceMX::MetricsAdmin::end_enableMetricsView(const ::Ice::AsyncResultPtr& result)
+IceMX::DispatchMetrics::_iceWriteImpl(Ice::OutputStream* ostr) const
 {
-    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_enableMetricsView_name);
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    result->_readEmptyParams();
-}
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::_iceI_begin_disableMetricsView(const ::std::string& iceP_name, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
-{
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_disableMetricsView_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_disableMetricsView_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_IceMX_MetricsAdmin_disableMetricsView_name, ::Ice::Normal, context);
-        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
-        ostr->write(iceP_name);
-        result->endWriteParams();
-        result->invoke(iceC_IceMX_MetricsAdmin_disableMetricsView_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
-}
-
-void
-IceProxy::IceMX::MetricsAdmin::end_disableMetricsView(const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_disableMetricsView_name);
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    result->_readEmptyParams();
-}
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsView(const ::std::string& iceP_view, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
-{
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsView_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsView_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsView_name, ::Ice::Normal, context);
-        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
-        ostr->write(iceP_view);
-        result->endWriteParams();
-        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsView_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
-}
-
-::IceMX::MetricsView
-IceProxy::IceMX::MetricsAdmin::end_getMetricsView(::Ice::Long& iceP_timestamp, const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsView_name);
-    ::IceMX::MetricsView ret;
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(iceP_timestamp);
-    istr->read(ret);
-    istr->readPendingValues();
-    result->_endReadParams();
-    return ret;
-}
-
-void IceProxy::IceMX::MetricsAdmin::_iceI_end_getMetricsView(::Ice::Long& iceP_timestamp, ::IceMX::MetricsView& ret, const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsView_name);
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(iceP_timestamp);
-    istr->read(ret);
-    istr->readPendingValues();
-    result->_endReadParams();
-}
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMapMetricsFailures(const ::std::string& iceP_view, const ::std::string& iceP_map, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
-{
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name, ::Ice::Normal, context);
-        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
-        ostr->write(iceP_view);
-        ostr->write(iceP_map);
-        result->endWriteParams();
-        result->invoke(iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
-}
-
-::IceMX::MetricsFailuresSeq
-IceProxy::IceMX::MetricsAdmin::end_getMapMetricsFailures(const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMapMetricsFailures_name);
-    ::IceMX::MetricsFailuresSeq ret;
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(ret);
-    result->_endReadParams();
-    return ret;
-}
-
-::Ice::AsyncResultPtr
-IceProxy::IceMX::MetricsAdmin::_iceI_begin_getMetricsFailures(const ::std::string& iceP_view, const ::std::string& iceP_map, const ::std::string& iceP_id, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
-{
-    _checkTwowayOnly(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceMX_MetricsAdmin_getMetricsFailures_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_IceMX_MetricsAdmin_getMetricsFailures_name, ::Ice::Normal, context);
-        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::SlicedFormat);
-        ostr->write(iceP_view);
-        ostr->write(iceP_map);
-        ostr->write(iceP_id);
-        result->endWriteParams();
-        result->invoke(iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
-}
-
-::IceMX::MetricsFailures
-IceProxy::IceMX::MetricsAdmin::end_getMetricsFailures(const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_IceMX_MetricsAdmin_getMetricsFailures_name);
-    ::IceMX::MetricsFailures ret;
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::IceMX::UnknownMetricsView&)
-        {
-            throw;
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(ret);
-    result->_endReadParams();
-    return ret;
-}
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::MetricsAdmin::_newInstance() const
-{
-    return new MetricsAdmin;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::IceMX::MetricsAdmin::ice_staticId()
-{
-    return ::IceMX::MetricsAdmin::ice_staticId();
-}
-
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ThreadMetrics* p) { return p; }
-
-void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ThreadMetrics>& v)
-{
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new ThreadMetrics;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::ThreadMetrics::_newInstance() const
-{
-    return new ThreadMetrics;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::IceMX::ThreadMetrics::ice_staticId()
-{
-    return ::IceMX::ThreadMetrics::ice_staticId();
-}
-
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(DispatchMetrics* p) { return p; }
-
-void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< DispatchMetrics>& v)
-{
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new DispatchMetrics;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::DispatchMetrics::_newInstance() const
-{
-    return new DispatchMetrics;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::IceMX::DispatchMetrics::ice_staticId()
-{
-    return ::IceMX::DispatchMetrics::ice_staticId();
-}
-
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ChildInvocationMetrics* p) { return p; }
-
-void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ChildInvocationMetrics>& v)
-{
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new ChildInvocationMetrics;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::ChildInvocationMetrics::_newInstance() const
-{
-    return new ChildInvocationMetrics;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::IceMX::ChildInvocationMetrics::ice_staticId()
-{
-    return ::IceMX::ChildInvocationMetrics::ice_staticId();
-}
-
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(CollocatedMetrics* p) { return p; }
-
-void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< CollocatedMetrics>& v)
-{
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new CollocatedMetrics;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::CollocatedMetrics::_newInstance() const
-{
-    return new CollocatedMetrics;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::IceMX::CollocatedMetrics::ice_staticId()
-{
-    return ::IceMX::CollocatedMetrics::ice_staticId();
-}
-
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(RemoteMetrics* p) { return p; }
-
-void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< RemoteMetrics>& v)
-{
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new RemoteMetrics;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::RemoteMetrics::_newInstance() const
-{
-    return new RemoteMetrics;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::IceMX::RemoteMetrics::ice_staticId()
-{
-    return ::IceMX::RemoteMetrics::ice_staticId();
-}
-
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(InvocationMetrics* p) { return p; }
-
-void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< InvocationMetrics>& v)
-{
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new InvocationMetrics;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::InvocationMetrics::_newInstance() const
-{
-    return new InvocationMetrics;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::IceMX::InvocationMetrics::ice_staticId()
-{
-    return ::IceMX::InvocationMetrics::ice_staticId();
-}
-
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::IceMX::upCast(ConnectionMetrics* p) { return p; }
-
-void
-::IceProxy::IceMX::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< ConnectionMetrics>& v)
-{
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new ConnectionMetrics;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::IceMX::ConnectionMetrics::_newInstance() const
-{
-    return new ConnectionMetrics;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::IceMX::ConnectionMetrics::ice_staticId()
-{
-    return ::IceMX::ConnectionMetrics::ice_staticId();
-}
-
-IceMX::Metrics::~Metrics()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(Metrics* p) { return p; }
-
-/// \endcond
-::Ice::ObjectPtr
-IceMX::Metrics::ice_clone() const
-{
-    ::Ice::Object* p = new Metrics(*this);
-    return p;
-}
-
-namespace
-{
-const ::std::string iceC_IceMX_Metrics_ids[2] =
-{
-    "::Ice::Object",
-    "::IceMX::Metrics"
-};
-
-}
-
-bool
-IceMX::Metrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
-{
-    return ::std::binary_search(iceC_IceMX_Metrics_ids, iceC_IceMX_Metrics_ids + 2, s);
-}
-
-::std::vector< ::std::string>
-IceMX::Metrics::ice_ids(const ::Ice::Current&) const
-{
-    return ::std::vector< ::std::string>(&iceC_IceMX_Metrics_ids[0], &iceC_IceMX_Metrics_ids[2]);
-}
-
-const ::std::string&
-IceMX::Metrics::ice_id(const ::Ice::Current&) const
-{
-    return ice_staticId();
-}
-
-const ::std::string&
-IceMX::Metrics::ice_staticId()
-{
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::Metrics";
-    return typeId;
-#else
-    return iceC_IceMX_Metrics_ids[1];
-#endif
-}
-
-/// \cond STREAM
-void
-IceMX::Metrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
-{
-    ostr->startSlice(ice_staticId(), -1, true);
-    ::Ice::StreamWriter< Metrics, ::Ice::OutputStream>::write(ostr, *this);
-    ostr->endSlice();
-}
-
-void
-IceMX::Metrics::_iceReadImpl(::Ice::InputStream* istr)
-{
-    istr->startSlice();
-    ::Ice::StreamReader< Metrics, ::Ice::InputStream>::read(istr, *this);
-    istr->endSlice();
-}
-/// \endcond
-
-namespace
-{
-const ::IceInternal::DefaultValueFactoryInit< ::IceMX::Metrics> iceC_IceMX_Metrics_init("::IceMX::Metrics");
-}
-
-::Ice::ValueFactoryPtr
-IceMX::Metrics::ice_factory()
-{
-    return ::IceInternal::factoryTable->getValueFactory(::IceMX::Metrics::ice_staticId());
-}
-
-/// \cond INTERNAL
-void
-IceMX::_icePatchObjectPtr(MetricsPtr& handle, const ::Ice::ObjectPtr& v)
-{
-    handle = MetricsPtr::dynamicCast(v);
-    if(v && !handle)
-    {
-        IceInternal::Ex::throwUOE(Metrics::ice_staticId(), v);
-    }
-}
-/// \endcond
-
-IceMX::MetricsAdmin::~MetricsAdmin()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(MetricsAdmin* p) { return p; }
-
-/// \endcond
-
-namespace
-{
-const ::std::string iceC_IceMX_MetricsAdmin_ids[2] =
-{
-    "::Ice::Object",
-    "::IceMX::MetricsAdmin"
-};
-
-}
-
-bool
-IceMX::MetricsAdmin::ice_isA(const ::std::string& s, const ::Ice::Current&) const
-{
-    return ::std::binary_search(iceC_IceMX_MetricsAdmin_ids, iceC_IceMX_MetricsAdmin_ids + 2, s);
-}
-
-::std::vector< ::std::string>
-IceMX::MetricsAdmin::ice_ids(const ::Ice::Current&) const
-{
-    return ::std::vector< ::std::string>(&iceC_IceMX_MetricsAdmin_ids[0], &iceC_IceMX_MetricsAdmin_ids[2]);
-}
-
-const ::std::string&
-IceMX::MetricsAdmin::ice_id(const ::Ice::Current&) const
-{
-    return ice_staticId();
-}
-
-const ::std::string&
-IceMX::MetricsAdmin::ice_staticId()
-{
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::MetricsAdmin";
-    return typeId;
-#else
-    return iceC_IceMX_MetricsAdmin_ids[1];
-#endif
-}
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_getMetricsViewNames(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::Normal, current.mode);
-    inS.readEmptyParams();
-    inS.setFormat(::Ice::SlicedFormat);
-    ::Ice::StringSeq iceP_disabledViews;
-    ::Ice::StringSeq ret = this->getMetricsViewNames(iceP_disabledViews, current);
-    ::Ice::OutputStream* ostr = inS.startWriteParams();
-    ostr->write(iceP_disabledViews);
-    ostr->write(ret);
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_enableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::Normal, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
-    ::std::string iceP_name;
-    istr->read(iceP_name);
-    inS.endReadParams();
-    inS.setFormat(::Ice::SlicedFormat);
-    this->enableMetricsView(iceP_name, current);
-    inS.writeEmptyParams();
-    return true;
-}
-/// \endcond
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_disableMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::Normal, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
-    ::std::string iceP_name;
-    istr->read(iceP_name);
-    inS.endReadParams();
-    inS.setFormat(::Ice::SlicedFormat);
-    this->disableMetricsView(iceP_name, current);
-    inS.writeEmptyParams();
-    return true;
-}
-/// \endcond
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_getMetricsView(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::Normal, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
-    ::std::string iceP_view;
-    istr->read(iceP_view);
-    inS.endReadParams();
-    inS.setFormat(::Ice::SlicedFormat);
-    ::Ice::Long iceP_timestamp;
-    MetricsView ret = this->getMetricsView(iceP_view, iceP_timestamp, current);
-    ::Ice::OutputStream* ostr = inS.startWriteParams();
-    ostr->write(iceP_timestamp);
-    ostr->write(ret);
-    ostr->writePendingValues();
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::Normal, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
-    ::std::string iceP_view;
-    ::std::string iceP_map;
-    istr->read(iceP_view);
-    istr->read(iceP_map);
-    inS.endReadParams();
-    inS.setFormat(::Ice::SlicedFormat);
-    MetricsFailuresSeq ret = this->getMapMetricsFailures(iceP_view, iceP_map, current);
-    ::Ice::OutputStream* ostr = inS.startWriteParams();
-    ostr->write(ret);
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceD_getMetricsFailures(::IceInternal::Incoming& inS, const ::Ice::Current& current)
-{
-    _iceCheckMode(::Ice::Normal, current.mode);
-    ::Ice::InputStream* istr = inS.startReadParams();
-    ::std::string iceP_view;
-    ::std::string iceP_map;
-    ::std::string iceP_id;
-    istr->read(iceP_view);
-    istr->read(iceP_map);
-    istr->read(iceP_id);
-    inS.endReadParams();
-    inS.setFormat(::Ice::SlicedFormat);
-    MetricsFailures ret = this->getMetricsFailures(iceP_view, iceP_map, iceP_id, current);
-    ::Ice::OutputStream* ostr = inS.startWriteParams();
-    ostr->write(ret);
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
-
-namespace
-{
-const ::std::string iceC_IceMX_MetricsAdmin_all[] =
-{
-    "disableMetricsView",
-    "enableMetricsView",
-    "getMapMetricsFailures",
-    "getMetricsFailures",
-    "getMetricsView",
-    "getMetricsViewNames",
-    "ice_id",
-    "ice_ids",
-    "ice_isA",
-    "ice_ping"
-};
-
-}
-
-/// \cond INTERNAL
-bool
-IceMX::MetricsAdmin::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
-{
-    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceMX_MetricsAdmin_all, iceC_IceMX_MetricsAdmin_all + 10, current.operation);
-    if(r.first == r.second)
-    {
-        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
-    }
-
-    switch(r.first - iceC_IceMX_MetricsAdmin_all)
-    {
-        case 0:
-        {
-            return _iceD_disableMetricsView(in, current);
-        }
-        case 1:
-        {
-            return _iceD_enableMetricsView(in, current);
-        }
-        case 2:
-        {
-            return _iceD_getMapMetricsFailures(in, current);
-        }
-        case 3:
-        {
-            return _iceD_getMetricsFailures(in, current);
-        }
-        case 4:
-        {
-            return _iceD_getMetricsView(in, current);
-        }
-        case 5:
-        {
-            return _iceD_getMetricsViewNames(in, current);
-        }
-        case 6:
-        {
-            return _iceD_ice_id(in, current);
-        }
-        case 7:
-        {
-            return _iceD_ice_ids(in, current);
-        }
-        case 8:
-        {
-            return _iceD_ice_isA(in, current);
-        }
-        case 9:
-        {
-            return _iceD_ice_ping(in, current);
-        }
-        default:
-        {
-            assert(false);
-            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
-        }
-    }
-}
-/// \endcond
-
-/// \cond STREAM
-void
-IceMX::MetricsAdmin::_iceWriteImpl(::Ice::OutputStream* ostr) const
-{
-    ostr->startSlice(ice_staticId(), -1, true);
-    ::Ice::StreamWriter< MetricsAdmin, ::Ice::OutputStream>::write(ostr, *this);
-    ostr->endSlice();
-}
-
-void
-IceMX::MetricsAdmin::_iceReadImpl(::Ice::InputStream* istr)
-{
-    istr->startSlice();
-    ::Ice::StreamReader< MetricsAdmin, ::Ice::InputStream>::read(istr, *this);
-    istr->endSlice();
-}
-/// \endcond
-
-/// \cond INTERNAL
-void
-IceMX::_icePatchObjectPtr(MetricsAdminPtr& handle, const ::Ice::ObjectPtr& v)
-{
-    handle = MetricsAdminPtr::dynamicCast(v);
-    if(v && !handle)
-    {
-        IceInternal::Ex::throwUOE(MetricsAdmin::ice_staticId(), v);
-    }
-}
-/// \endcond
-
-IceMX::ThreadMetrics::~ThreadMetrics()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(ThreadMetrics* p) { return p; }
-
-/// \endcond
-::Ice::ObjectPtr
-IceMX::ThreadMetrics::ice_clone() const
-{
-    ::Ice::Object* p = new ThreadMetrics(*this);
-    return p;
-}
-
-namespace
-{
-const ::std::string iceC_IceMX_ThreadMetrics_ids[3] =
-{
-    "::Ice::Object",
-    "::IceMX::Metrics",
-    "::IceMX::ThreadMetrics"
-};
-
-}
-
-bool
-IceMX::ThreadMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
-{
-    return ::std::binary_search(iceC_IceMX_ThreadMetrics_ids, iceC_IceMX_ThreadMetrics_ids + 3, s);
-}
-
-::std::vector< ::std::string>
-IceMX::ThreadMetrics::ice_ids(const ::Ice::Current&) const
-{
-    return ::std::vector< ::std::string>(&iceC_IceMX_ThreadMetrics_ids[0], &iceC_IceMX_ThreadMetrics_ids[3]);
-}
-
-const ::std::string&
-IceMX::ThreadMetrics::ice_id(const ::Ice::Current&) const
-{
-    return ice_staticId();
-}
-
-const ::std::string&
-IceMX::ThreadMetrics::ice_staticId()
-{
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::ThreadMetrics";
-    return typeId;
-#else
-    return iceC_IceMX_ThreadMetrics_ids[2];
-#endif
-}
-
-/// \cond STREAM
-void
-IceMX::ThreadMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
-{
-    ostr->startSlice(ice_staticId(), -1, false);
-    ::Ice::StreamWriter< ThreadMetrics, ::Ice::OutputStream>::write(ostr, *this);
-    ostr->endSlice();
-    Metrics::_iceWriteImpl(ostr);
-}
-
-void
-IceMX::ThreadMetrics::_iceReadImpl(::Ice::InputStream* istr)
-{
-    istr->startSlice();
-    ::Ice::StreamReader< ThreadMetrics, ::Ice::InputStream>::read(istr, *this);
-    istr->endSlice();
-    Metrics::_iceReadImpl(istr);
-}
-/// \endcond
-
-namespace
-{
-const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ThreadMetrics> iceC_IceMX_ThreadMetrics_init("::IceMX::ThreadMetrics");
-}
-
-::Ice::ValueFactoryPtr
-IceMX::ThreadMetrics::ice_factory()
-{
-    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ThreadMetrics::ice_staticId());
-}
-
-/// \cond INTERNAL
-void
-IceMX::_icePatchObjectPtr(ThreadMetricsPtr& handle, const ::Ice::ObjectPtr& v)
-{
-    handle = ThreadMetricsPtr::dynamicCast(v);
-    if(v && !handle)
-    {
-        IceInternal::Ex::throwUOE(ThreadMetrics::ice_staticId(), v);
-    }
-}
-/// \endcond
-
-IceMX::DispatchMetrics::~DispatchMetrics()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(DispatchMetrics* p) { return p; }
-
-/// \endcond
-::Ice::ObjectPtr
-IceMX::DispatchMetrics::ice_clone() const
-{
-    ::Ice::Object* p = new DispatchMetrics(*this);
-    return p;
-}
-
-namespace
-{
-const ::std::string iceC_IceMX_DispatchMetrics_ids[3] =
-{
-    "::Ice::Object",
-    "::IceMX::DispatchMetrics",
-    "::IceMX::Metrics"
-};
-
-}
-
-bool
-IceMX::DispatchMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
-{
-    return ::std::binary_search(iceC_IceMX_DispatchMetrics_ids, iceC_IceMX_DispatchMetrics_ids + 3, s);
-}
-
-::std::vector< ::std::string>
-IceMX::DispatchMetrics::ice_ids(const ::Ice::Current&) const
-{
-    return ::std::vector< ::std::string>(&iceC_IceMX_DispatchMetrics_ids[0], &iceC_IceMX_DispatchMetrics_ids[3]);
-}
-
-const ::std::string&
-IceMX::DispatchMetrics::ice_id(const ::Ice::Current&) const
-{
-    return ice_staticId();
-}
-
-const ::std::string&
-IceMX::DispatchMetrics::ice_staticId()
-{
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::DispatchMetrics";
-    return typeId;
-#else
-    return iceC_IceMX_DispatchMetrics_ids[1];
-#endif
-}
-
-/// \cond STREAM
-void
-IceMX::DispatchMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
-{
-    ostr->startSlice(ice_staticId(), -1, false);
-    ::Ice::StreamWriter< DispatchMetrics, ::Ice::OutputStream>::write(ostr, *this);
-    ostr->endSlice();
-    Metrics::_iceWriteImpl(ostr);
-}
-
-void
-IceMX::DispatchMetrics::_iceReadImpl(::Ice::InputStream* istr)
-{
-    istr->startSlice();
-    ::Ice::StreamReader< DispatchMetrics, ::Ice::InputStream>::read(istr, *this);
-    istr->endSlice();
-    Metrics::_iceReadImpl(istr);
-}
-/// \endcond
-
-namespace
-{
-const ::IceInternal::DefaultValueFactoryInit< ::IceMX::DispatchMetrics> iceC_IceMX_DispatchMetrics_init("::IceMX::DispatchMetrics");
-}
-
-::Ice::ValueFactoryPtr
-IceMX::DispatchMetrics::ice_factory()
-{
-    return ::IceInternal::factoryTable->getValueFactory(::IceMX::DispatchMetrics::ice_staticId());
-}
-
-/// \cond INTERNAL
-void
-IceMX::_icePatchObjectPtr(DispatchMetricsPtr& handle, const ::Ice::ObjectPtr& v)
-{
-    handle = DispatchMetricsPtr::dynamicCast(v);
-    if(v && !handle)
-    {
-        IceInternal::Ex::throwUOE(DispatchMetrics::ice_staticId(), v);
-    }
-}
-/// \endcond
-
-IceMX::ChildInvocationMetrics::~ChildInvocationMetrics()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(ChildInvocationMetrics* p) { return p; }
-
-/// \endcond
-::Ice::ObjectPtr
-IceMX::ChildInvocationMetrics::ice_clone() const
-{
-    ::Ice::Object* p = new ChildInvocationMetrics(*this);
-    return p;
-}
-
-namespace
-{
-const ::std::string iceC_IceMX_ChildInvocationMetrics_ids[3] =
-{
-    "::Ice::Object",
-    "::IceMX::ChildInvocationMetrics",
-    "::IceMX::Metrics"
-};
-
-}
-
-bool
-IceMX::ChildInvocationMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
-{
-    return ::std::binary_search(iceC_IceMX_ChildInvocationMetrics_ids, iceC_IceMX_ChildInvocationMetrics_ids + 3, s);
-}
-
-::std::vector< ::std::string>
-IceMX::ChildInvocationMetrics::ice_ids(const ::Ice::Current&) const
-{
-    return ::std::vector< ::std::string>(&iceC_IceMX_ChildInvocationMetrics_ids[0], &iceC_IceMX_ChildInvocationMetrics_ids[3]);
-}
-
-const ::std::string&
-IceMX::ChildInvocationMetrics::ice_id(const ::Ice::Current&) const
-{
-    return ice_staticId();
-}
-
-const ::std::string&
-IceMX::ChildInvocationMetrics::ice_staticId()
-{
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::ChildInvocationMetrics";
-    return typeId;
-#else
-    return iceC_IceMX_ChildInvocationMetrics_ids[1];
-#endif
-}
-
-/// \cond STREAM
-void
-IceMX::ChildInvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
-{
-    ostr->startSlice(ice_staticId(), -1, false);
-    ::Ice::StreamWriter< ChildInvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
-    ostr->endSlice();
-    Metrics::_iceWriteImpl(ostr);
-}
-
-void
-IceMX::ChildInvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
-{
-    istr->startSlice();
-    ::Ice::StreamReader< ChildInvocationMetrics, ::Ice::InputStream>::read(istr, *this);
-    istr->endSlice();
-    Metrics::_iceReadImpl(istr);
-}
-/// \endcond
-
-namespace
-{
-const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ChildInvocationMetrics> iceC_IceMX_ChildInvocationMetrics_init("::IceMX::ChildInvocationMetrics");
-}
-
-::Ice::ValueFactoryPtr
-IceMX::ChildInvocationMetrics::ice_factory()
-{
-    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ChildInvocationMetrics::ice_staticId());
-}
-
-/// \cond INTERNAL
-void
-IceMX::_icePatchObjectPtr(ChildInvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
-{
-    handle = ChildInvocationMetricsPtr::dynamicCast(v);
-    if(v && !handle)
-    {
-        IceInternal::Ex::throwUOE(ChildInvocationMetrics::ice_staticId(), v);
-    }
-}
-/// \endcond
-
-IceMX::CollocatedMetrics::~CollocatedMetrics()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(CollocatedMetrics* p) { return p; }
-
-/// \endcond
-::Ice::ObjectPtr
-IceMX::CollocatedMetrics::ice_clone() const
-{
-    ::Ice::Object* p = new CollocatedMetrics(*this);
-    return p;
+    ostr->startSlice(ice_staticId(), -1, false);
+    ostr->writeAll(this->userException, this->size, this->replySize);
+    ostr->endSlice();
+    Metrics::_iceWriteImpl(ostr);
 }
 
-namespace
-{
-const ::std::string iceC_IceMX_CollocatedMetrics_ids[4] =
+void
+IceMX::DispatchMetrics::_iceReadImpl(Ice::InputStream* istr)
 {
-    "::Ice::Object",
-    "::IceMX::ChildInvocationMetrics",
-    "::IceMX::CollocatedMetrics",
-    "::IceMX::Metrics"
-};
-
+    istr->startSlice();
+    istr->readAll(this->userException, this->size, this->replySize);
+    istr->endSlice();
+    Metrics::_iceReadImpl(istr);
 }
 
-bool
-IceMX::CollocatedMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+const char*
+IceMX::ChildInvocationMetrics::ice_staticId() noexcept
 {
-    return ::std::binary_search(iceC_IceMX_CollocatedMetrics_ids, iceC_IceMX_CollocatedMetrics_ids + 4, s);
+    return "::IceMX::ChildInvocationMetrics";
 }
 
-::std::vector< ::std::string>
-IceMX::CollocatedMetrics::ice_ids(const ::Ice::Current&) const
+const char*
+IceMX::ChildInvocationMetrics::ice_id() const noexcept
 {
-    return ::std::vector< ::std::string>(&iceC_IceMX_CollocatedMetrics_ids[0], &iceC_IceMX_CollocatedMetrics_ids[4]);
+    return ice_staticId();
 }
 
-const ::std::string&
-IceMX::CollocatedMetrics::ice_id(const ::Ice::Current&) const
+void
+IceMX::ChildInvocationMetrics::ice_printFields(std::ostream& os) const
 {
-    return ice_staticId();
+    Metrics::ice_printFields(os);
+    Ice::print(os << ", size = ", this->size);
+    Ice::print(os << ", replySize = ", this->replySize);
 }
 
-const ::std::string&
-IceMX::CollocatedMetrics::ice_staticId()
+Ice::ValuePtr
+IceMX::ChildInvocationMetrics::_iceCloneImpl() const
 {
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::CollocatedMetrics";
-    return typeId;
-#else
-    return iceC_IceMX_CollocatedMetrics_ids[2];
-#endif
+    return CloneEnabler<ChildInvocationMetrics>::clone(*this);
 }
 
-/// \cond STREAM
 void
-IceMX::CollocatedMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+IceMX::ChildInvocationMetrics::_iceWriteImpl(Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    ::Ice::StreamWriter< CollocatedMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->writeAll(this->size, this->replySize);
     ostr->endSlice();
-    ChildInvocationMetrics::_iceWriteImpl(ostr);
+    Metrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::CollocatedMetrics::_iceReadImpl(::Ice::InputStream* istr)
+IceMX::ChildInvocationMetrics::_iceReadImpl(Ice::InputStream* istr)
 {
     istr->startSlice();
-    ::Ice::StreamReader< CollocatedMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->readAll(this->size, this->replySize);
     istr->endSlice();
-    ChildInvocationMetrics::_iceReadImpl(istr);
-}
-/// \endcond
-
-namespace
-{
-const ::IceInternal::DefaultValueFactoryInit< ::IceMX::CollocatedMetrics> iceC_IceMX_CollocatedMetrics_init("::IceMX::CollocatedMetrics");
-}
-
-::Ice::ValueFactoryPtr
-IceMX::CollocatedMetrics::ice_factory()
-{
-    return ::IceInternal::factoryTable->getValueFactory(::IceMX::CollocatedMetrics::ice_staticId());
+    Metrics::_iceReadImpl(istr);
 }
 
-/// \cond INTERNAL
-void
-IceMX::_icePatchObjectPtr(CollocatedMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+const char*
+IceMX::CollocatedMetrics::ice_staticId() noexcept
 {
-    handle = CollocatedMetricsPtr::dynamicCast(v);
-    if(v && !handle)
-    {
-        IceInternal::Ex::throwUOE(CollocatedMetrics::ice_staticId(), v);
-    }
+    return "::IceMX::CollocatedMetrics";
 }
-/// \endcond
 
-IceMX::RemoteMetrics::~RemoteMetrics()
+const char*
+IceMX::CollocatedMetrics::ice_id() const noexcept
 {
+    return ice_staticId();
 }
 
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(RemoteMetrics* p) { return p; }
-
-/// \endcond
-::Ice::ObjectPtr
-IceMX::RemoteMetrics::ice_clone() const
+Ice::ValuePtr
+IceMX::CollocatedMetrics::_iceCloneImpl() const
 {
-    ::Ice::Object* p = new RemoteMetrics(*this);
-    return p;
+    return CloneEnabler<CollocatedMetrics>::clone(*this);
 }
 
-namespace
-{
-const ::std::string iceC_IceMX_RemoteMetrics_ids[4] =
+void
+IceMX::CollocatedMetrics::_iceWriteImpl(Ice::OutputStream* ostr) const
 {
-    "::Ice::Object",
-    "::IceMX::ChildInvocationMetrics",
-    "::IceMX::Metrics",
-    "::IceMX::RemoteMetrics"
-};
-
+    ostr->startSlice(ice_staticId(), -1, false);
+    ostr->endSlice();
+    ChildInvocationMetrics::_iceWriteImpl(ostr);
 }
 
-bool
-IceMX::RemoteMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+void
+IceMX::CollocatedMetrics::_iceReadImpl(Ice::InputStream* istr)
 {
-    return ::std::binary_search(iceC_IceMX_RemoteMetrics_ids, iceC_IceMX_RemoteMetrics_ids + 4, s);
+    istr->startSlice();
+    istr->endSlice();
+    ChildInvocationMetrics::_iceReadImpl(istr);
 }
 
-::std::vector< ::std::string>
-IceMX::RemoteMetrics::ice_ids(const ::Ice::Current&) const
+const char*
+IceMX::RemoteMetrics::ice_staticId() noexcept
 {
-    return ::std::vector< ::std::string>(&iceC_IceMX_RemoteMetrics_ids[0], &iceC_IceMX_RemoteMetrics_ids[4]);
+    return "::IceMX::RemoteMetrics";
 }
 
-const ::std::string&
-IceMX::RemoteMetrics::ice_id(const ::Ice::Current&) const
+const char*
+IceMX::RemoteMetrics::ice_id() const noexcept
 {
     return ice_staticId();
 }
 
-const ::std::string&
-IceMX::RemoteMetrics::ice_staticId()
+Ice::ValuePtr
+IceMX::RemoteMetrics::_iceCloneImpl() const
 {
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::RemoteMetrics";
-    return typeId;
-#else
-    return iceC_IceMX_RemoteMetrics_ids[3];
-#endif
+    return CloneEnabler<RemoteMetrics>::clone(*this);
 }
 
-/// \cond STREAM
 void
-IceMX::RemoteMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+IceMX::RemoteMetrics::_iceWriteImpl(Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    ::Ice::StreamWriter< RemoteMetrics, ::Ice::OutputStream>::write(ostr, *this);
     ostr->endSlice();
     ChildInvocationMetrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::RemoteMetrics::_iceReadImpl(::Ice::InputStream* istr)
+IceMX::RemoteMetrics::_iceReadImpl(Ice::InputStream* istr)
 {
     istr->startSlice();
-    ::Ice::StreamReader< RemoteMetrics, ::Ice::InputStream>::read(istr, *this);
     istr->endSlice();
     ChildInvocationMetrics::_iceReadImpl(istr);
 }
-/// \endcond
 
-namespace
+const char*
+IceMX::InvocationMetrics::ice_staticId() noexcept
 {
-const ::IceInternal::DefaultValueFactoryInit< ::IceMX::RemoteMetrics> iceC_IceMX_RemoteMetrics_init("::IceMX::RemoteMetrics");
+    return "::IceMX::InvocationMetrics";
 }
 
-::Ice::ValueFactoryPtr
-IceMX::RemoteMetrics::ice_factory()
+const char*
+IceMX::InvocationMetrics::ice_id() const noexcept
 {
-    return ::IceInternal::factoryTable->getValueFactory(::IceMX::RemoteMetrics::ice_staticId());
+    return ice_staticId();
 }
 
-/// \cond INTERNAL
 void
-IceMX::_icePatchObjectPtr(RemoteMetricsPtr& handle, const ::Ice::ObjectPtr& v)
-{
-    handle = RemoteMetricsPtr::dynamicCast(v);
-    if(v && !handle)
-    {
-        IceInternal::Ex::throwUOE(RemoteMetrics::ice_staticId(), v);
-    }
-}
-/// \endcond
-
-IceMX::InvocationMetrics::~InvocationMetrics()
+IceMX::InvocationMetrics::ice_printFields(std::ostream& os) const
 {
+    Metrics::ice_printFields(os);
+    Ice::print(os << ", retry = ", this->retry);
+    Ice::print(os << ", userException = ", this->userException);
+    Ice::print(os << ", remotes = ", this->remotes);
+    Ice::print(os << ", collocated = ", this->collocated);
 }
 
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(InvocationMetrics* p) { return p; }
-
-/// \endcond
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1900)
-#   pragma warning(push)
-#   pragma warning(disable:4589)
-#endif
-::Ice::ObjectPtr
-IceMX::InvocationMetrics::ice_clone() const
+Ice::ValuePtr
+IceMX::InvocationMetrics::_iceCloneImpl() const
 {
-    ::Ice::Object* p = new InvocationMetrics(*this);
-    return p;
+    return CloneEnabler<InvocationMetrics>::clone(*this);
 }
-#if defined(_MSC_VER) && (_MSC_VER >= 1900)
-#   pragma warning(pop)
-#endif
 
-namespace
-{
-const ::std::string iceC_IceMX_InvocationMetrics_ids[3] =
+void
+IceMX::InvocationMetrics::_iceWriteImpl(Ice::OutputStream* ostr) const
 {
-    "::Ice::Object",
-    "::IceMX::InvocationMetrics",
-    "::IceMX::Metrics"
-};
-
+    ostr->startSlice(ice_staticId(), -1, false);
+    ostr->writeAll(this->retry, this->userException, this->remotes, this->collocated);
+    ostr->endSlice();
+    Metrics::_iceWriteImpl(ostr);
 }
 
-bool
-IceMX::InvocationMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+void
+IceMX::InvocationMetrics::_iceReadImpl(Ice::InputStream* istr)
 {
-    return ::std::binary_search(iceC_IceMX_InvocationMetrics_ids, iceC_IceMX_InvocationMetrics_ids + 3, s);
+    istr->startSlice();
+    istr->readAll(this->retry, this->userException, this->remotes, this->collocated);
+    istr->endSlice();
+    Metrics::_iceReadImpl(istr);
 }
 
-::std::vector< ::std::string>
-IceMX::InvocationMetrics::ice_ids(const ::Ice::Current&) const
+const char*
+IceMX::ConnectionMetrics::ice_staticId() noexcept
 {
-    return ::std::vector< ::std::string>(&iceC_IceMX_InvocationMetrics_ids[0], &iceC_IceMX_InvocationMetrics_ids[3]);
+    return "::IceMX::ConnectionMetrics";
 }
 
-const ::std::string&
-IceMX::InvocationMetrics::ice_id(const ::Ice::Current&) const
+const char*
+IceMX::ConnectionMetrics::ice_id() const noexcept
 {
     return ice_staticId();
 }
 
-const ::std::string&
-IceMX::InvocationMetrics::ice_staticId()
+void
+IceMX::ConnectionMetrics::ice_printFields(std::ostream& os) const
 {
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::InvocationMetrics";
-    return typeId;
-#else
-    return iceC_IceMX_InvocationMetrics_ids[1];
-#endif
+    Metrics::ice_printFields(os);
+    Ice::print(os << ", receivedBytes = ", this->receivedBytes);
+    Ice::print(os << ", sentBytes = ", this->sentBytes);
 }
 
-void
-IceMX::InvocationMetrics::_iceGcVisitMembers(::IceInternal::GCVisitor& v_)
+Ice::ValuePtr
+IceMX::ConnectionMetrics::_iceCloneImpl() const
 {
-    {
-        for(::IceMX::MetricsMap::iterator _i0 = remotes.begin(); _i0 != remotes.end(); ++_i0)
-        {
-            if((*_i0))
-            {
-                if((::IceMX::upCast((*_i0).get())->_iceGcVisit(v_)))
-                {
-                    (*_i0) = 0;
-                }
-            }
-        }
-    }
-    {
-        for(::IceMX::MetricsMap::iterator _i0 = collocated.begin(); _i0 != collocated.end(); ++_i0)
-        {
-            if((*_i0))
-            {
-                if((::IceMX::upCast((*_i0).get())->_iceGcVisit(v_)))
-                {
-                    (*_i0) = 0;
-                }
-            }
-        }
-    }
+    return CloneEnabler<ConnectionMetrics>::clone(*this);
 }
 
-/// \cond STREAM
 void
-IceMX::InvocationMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
+IceMX::ConnectionMetrics::_iceWriteImpl(Ice::OutputStream* ostr) const
 {
     ostr->startSlice(ice_staticId(), -1, false);
-    ::Ice::StreamWriter< InvocationMetrics, ::Ice::OutputStream>::write(ostr, *this);
+    ostr->writeAll(this->receivedBytes, this->sentBytes);
     ostr->endSlice();
     Metrics::_iceWriteImpl(ostr);
 }
 
 void
-IceMX::InvocationMetrics::_iceReadImpl(::Ice::InputStream* istr)
+IceMX::ConnectionMetrics::_iceReadImpl(Ice::InputStream* istr)
 {
     istr->startSlice();
-    ::Ice::StreamReader< InvocationMetrics, ::Ice::InputStream>::read(istr, *this);
+    istr->readAll(this->receivedBytes, this->sentBytes);
     istr->endSlice();
     Metrics::_iceReadImpl(istr);
 }
-/// \endcond
 
-namespace
+void
+IceMX::MetricsAdmin::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
 {
-const ::IceInternal::DefaultValueFactoryInit< ::IceMX::InvocationMetrics> iceC_IceMX_InvocationMetrics_init("::IceMX::InvocationMetrics");
+    static constexpr std::array<std::string_view, 10> allOperations{"disableMetricsView", "enableMetricsView", "getMapMetricsFailures", "getMetricsFailures", "getMetricsView", "getMetricsViewNames", "ice_id", "ice_ids", "ice_isA", "ice_ping"};
+
+    const Ice::Current& current = request.current();
+    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
+    if (r.first == r.second)
+    {
+        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
+        return;
+    }
+
+    switch (r.first - allOperations.begin())
+    {
+        case 0:
+        {
+            _iceD_disableMetricsView(request, std::move(sendResponse));
+            break;
+        }
+        case 1:
+        {
+            _iceD_enableMetricsView(request, std::move(sendResponse));
+            break;
+        }
+        case 2:
+        {
+            _iceD_getMapMetricsFailures(request, std::move(sendResponse));
+            break;
+        }
+        case 3:
+        {
+            _iceD_getMetricsFailures(request, std::move(sendResponse));
+            break;
+        }
+        case 4:
+        {
+            _iceD_getMetricsView(request, std::move(sendResponse));
+            break;
+        }
+        case 5:
+        {
+            _iceD_getMetricsViewNames(request, std::move(sendResponse));
+            break;
+        }
+        case 6:
+        {
+            _iceD_ice_id(request, std::move(sendResponse));
+            break;
+        }
+        case 7:
+        {
+            _iceD_ice_ids(request, std::move(sendResponse));
+            break;
+        }
+        case 8:
+        {
+            _iceD_ice_isA(request, std::move(sendResponse));
+            break;
+        }
+        case 9:
+        {
+            _iceD_ice_ping(request, std::move(sendResponse));
+            break;
+        }
+        default:
+        {
+            assert(false);
+            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
+        }
+    }
 }
 
-::Ice::ValueFactoryPtr
-IceMX::InvocationMetrics::ice_factory()
+std::vector<std::string>
+IceMX::MetricsAdmin::ice_ids(const Ice::Current&) const
 {
-    return ::IceInternal::factoryTable->getValueFactory(::IceMX::InvocationMetrics::ice_staticId());
+    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::IceMX::MetricsAdmin"};
+    return allTypeIds;
 }
 
-/// \cond INTERNAL
-void
-IceMX::_icePatchObjectPtr(InvocationMetricsPtr& handle, const ::Ice::ObjectPtr& v)
+std::string
+IceMX::MetricsAdmin::ice_id(const Ice::Current&) const
 {
-    handle = InvocationMetricsPtr::dynamicCast(v);
-    if(v && !handle)
-    {
-        IceInternal::Ex::throwUOE(InvocationMetrics::ice_staticId(), v);
-    }
+    return std::string{ice_staticId()};
 }
-/// \endcond
 
-IceMX::ConnectionMetrics::~ConnectionMetrics()
+void
+IceMX::MetricsAdmin::_iceD_getMetricsViewNames(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
 {
+    checkNonIdempotent(request.current());
+    request.inputStream().skipEmptyEncapsulation();
+    ::Ice::StringSeq iceP_disabledViews;
+    const ::Ice::StringSeq ret = this->getMetricsViewNames(iceP_disabledViews, request.current());
+    sendResponse(Ice::makeOutgoingResponse([&](Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(iceP_disabledViews, ret);
+        },
+        request.current()));
 }
 
-/// \cond INTERNAL
-ICE_API ::Ice::Object* IceMX::upCast(ConnectionMetrics* p) { return p; }
+void
+IceMX::MetricsAdmin::_iceD_enableMetricsView(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_name;
+    istr->readAll(iceP_name);
+    istr->endEncapsulation();
+    this->enableMetricsView(std::move(iceP_name), request.current());
+    sendResponse(Ice::makeEmptyOutgoingResponse(request.current()));
+}
 
-/// \endcond
-::Ice::ObjectPtr
-IceMX::ConnectionMetrics::ice_clone() const
-{
-    ::Ice::Object* p = new ConnectionMetrics(*this);
-    return p;
+void
+IceMX::MetricsAdmin::_iceD_disableMetricsView(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_name;
+    istr->readAll(iceP_name);
+    istr->endEncapsulation();
+    this->disableMetricsView(std::move(iceP_name), request.current());
+    sendResponse(Ice::makeEmptyOutgoingResponse(request.current()));
 }
 
-namespace
-{
-const ::std::string iceC_IceMX_ConnectionMetrics_ids[3] =
-{
-    "::Ice::Object",
-    "::IceMX::ConnectionMetrics",
-    "::IceMX::Metrics"
-};
+void
+IceMX::MetricsAdmin::_iceD_getMetricsView(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_view;
+    istr->readAll(iceP_view);
+    istr->endEncapsulation();
+    std::int64_t iceP_timestamp;
+    const MetricsView ret = this->getMetricsView(std::move(iceP_view), iceP_timestamp, request.current());
+    sendResponse(Ice::makeOutgoingResponse([&](Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(iceP_timestamp, ret);
+            ostr->writePendingValues();
+        },
+        request.current(),
+        Ice::FormatType::SlicedFormat));
+}
+
+void
+IceMX::MetricsAdmin::_iceD_getMapMetricsFailures(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_view;
+    std::string iceP_map;
+    istr->readAll(iceP_view, iceP_map);
+    istr->endEncapsulation();
+    const MetricsFailuresSeq ret = this->getMapMetricsFailures(std::move(iceP_view), std::move(iceP_map), request.current());
+    sendResponse(Ice::makeOutgoingResponse([&](Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(ret);
+        },
+        request.current()));
+}
 
+void
+IceMX::MetricsAdmin::_iceD_getMetricsFailures(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_view;
+    std::string iceP_map;
+    std::string iceP_id;
+    istr->readAll(iceP_view, iceP_map, iceP_id);
+    istr->endEncapsulation();
+    const MetricsFailures ret = this->getMetricsFailures(std::move(iceP_view), std::move(iceP_map), std::move(iceP_id), request.current());
+    sendResponse(Ice::makeOutgoingResponse([&](Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(ret);
+        },
+        request.current()));
 }
 
-bool
-IceMX::ConnectionMetrics::ice_isA(const ::std::string& s, const ::Ice::Current&) const
+const char*
+IceMX::MetricsAdmin::ice_staticId() noexcept
 {
-    return ::std::binary_search(iceC_IceMX_ConnectionMetrics_ids, iceC_IceMX_ConnectionMetrics_ids + 3, s);
+    return "::IceMX::MetricsAdmin";
 }
 
-::std::vector< ::std::string>
-IceMX::ConnectionMetrics::ice_ids(const ::Ice::Current&) const
+void
+IceMX::AsyncMetricsAdmin::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
 {
-    return ::std::vector< ::std::string>(&iceC_IceMX_ConnectionMetrics_ids[0], &iceC_IceMX_ConnectionMetrics_ids[3]);
+    static constexpr std::array<std::string_view, 10> allOperations{"disableMetricsView", "enableMetricsView", "getMapMetricsFailures", "getMetricsFailures", "getMetricsView", "getMetricsViewNames", "ice_id", "ice_ids", "ice_isA", "ice_ping"};
+
+    const Ice::Current& current = request.current();
+    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
+    if (r.first == r.second)
+    {
+        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
+        return;
+    }
+
+    switch (r.first - allOperations.begin())
+    {
+        case 0:
+        {
+            _iceD_disableMetricsView(request, std::move(sendResponse));
+            break;
+        }
+        case 1:
+        {
+            _iceD_enableMetricsView(request, std::move(sendResponse));
+            break;
+        }
+        case 2:
+        {
+            _iceD_getMapMetricsFailures(request, std::move(sendResponse));
+            break;
+        }
+        case 3:
+        {
+            _iceD_getMetricsFailures(request, std::move(sendResponse));
+            break;
+        }
+        case 4:
+        {
+            _iceD_getMetricsView(request, std::move(sendResponse));
+            break;
+        }
+        case 5:
+        {
+            _iceD_getMetricsViewNames(request, std::move(sendResponse));
+            break;
+        }
+        case 6:
+        {
+            _iceD_ice_id(request, std::move(sendResponse));
+            break;
+        }
+        case 7:
+        {
+            _iceD_ice_ids(request, std::move(sendResponse));
+            break;
+        }
+        case 8:
+        {
+            _iceD_ice_isA(request, std::move(sendResponse));
+            break;
+        }
+        case 9:
+        {
+            _iceD_ice_ping(request, std::move(sendResponse));
+            break;
+        }
+        default:
+        {
+            assert(false);
+            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
+        }
+    }
 }
 
-const ::std::string&
-IceMX::ConnectionMetrics::ice_id(const ::Ice::Current&) const
+std::vector<std::string>
+IceMX::AsyncMetricsAdmin::ice_ids(const Ice::Current&) const
 {
-    return ice_staticId();
+    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::IceMX::MetricsAdmin"};
+    return allTypeIds;
 }
 
-const ::std::string&
-IceMX::ConnectionMetrics::ice_staticId()
+std::string
+IceMX::AsyncMetricsAdmin::ice_id(const Ice::Current&) const
 {
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::IceMX::ConnectionMetrics";
-    return typeId;
-#else
-    return iceC_IceMX_ConnectionMetrics_ids[1];
-#endif
+    return std::string{ice_staticId()};
 }
 
-/// \cond STREAM
 void
-IceMX::ConnectionMetrics::_iceWriteImpl(::Ice::OutputStream* ostr) const
-{
-    ostr->startSlice(ice_staticId(), -1, false);
-    ::Ice::StreamWriter< ConnectionMetrics, ::Ice::OutputStream>::write(ostr, *this);
-    ostr->endSlice();
-    Metrics::_iceWriteImpl(ostr);
+IceMX::AsyncMetricsAdmin::_iceD_getMetricsViewNames(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse)
+{
+    checkNonIdempotent(request.current());
+    request.inputStream().skipEmptyEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    auto responseCb = [responseHandler](const ::Ice::StringSeq& ret, const ::Ice::StringSeq& iceP_disabledViews)
+    {
+        responseHandler->sendResponse(
+            [&](Ice::OutputStream* ostr)
+            {
+                ostr->writeAll(iceP_disabledViews, ret);
+            });
+    };
+    try
+    {
+        this->getMetricsViewNamesAsync(std::move(responseCb), [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
+    }
 }
 
 void
-IceMX::ConnectionMetrics::_iceReadImpl(::Ice::InputStream* istr)
-{
-    istr->startSlice();
-    ::Ice::StreamReader< ConnectionMetrics, ::Ice::InputStream>::read(istr, *this);
-    istr->endSlice();
-    Metrics::_iceReadImpl(istr);
+IceMX::AsyncMetricsAdmin::_iceD_enableMetricsView(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_name;
+    istr->readAll(iceP_name);
+    istr->endEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    try
+    {
+        this->enableMetricsViewAsync(std::move(iceP_name), [responseHandler] { responseHandler->sendEmptyResponse(); }, [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
+    }
 }
-/// \endcond
 
-namespace
-{
-const ::IceInternal::DefaultValueFactoryInit< ::IceMX::ConnectionMetrics> iceC_IceMX_ConnectionMetrics_init("::IceMX::ConnectionMetrics");
+void
+IceMX::AsyncMetricsAdmin::_iceD_disableMetricsView(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_name;
+    istr->readAll(iceP_name);
+    istr->endEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    try
+    {
+        this->disableMetricsViewAsync(std::move(iceP_name), [responseHandler] { responseHandler->sendEmptyResponse(); }, [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
+    }
 }
 
-::Ice::ValueFactoryPtr
-IceMX::ConnectionMetrics::ice_factory()
-{
-    return ::IceInternal::factoryTable->getValueFactory(::IceMX::ConnectionMetrics::ice_staticId());
+void
+IceMX::AsyncMetricsAdmin::_iceD_getMetricsView(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_view;
+    istr->readAll(iceP_view);
+    istr->endEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    auto responseCb = [responseHandler](const MetricsView& ret, std::int64_t iceP_timestamp)
+    {
+        responseHandler->sendResponse(
+            [&](Ice::OutputStream* ostr)
+            {
+                ostr->writeAll(iceP_timestamp, ret);
+                ostr->writePendingValues();
+            },
+            Ice::FormatType::SlicedFormat);
+    };
+    try
+    {
+        this->getMetricsViewAsync(std::move(iceP_view), std::move(responseCb), [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
+    }
 }
 
-/// \cond INTERNAL
 void
-IceMX::_icePatchObjectPtr(ConnectionMetricsPtr& handle, const ::Ice::ObjectPtr& v)
-{
-    handle = ConnectionMetricsPtr::dynamicCast(v);
-    if(v && !handle)
+IceMX::AsyncMetricsAdmin::_iceD_getMapMetricsFailures(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_view;
+    std::string iceP_map;
+    istr->readAll(iceP_view, iceP_map);
+    istr->endEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    auto responseCb = [responseHandler](const MetricsFailuresSeq& ret)
+    {
+        responseHandler->sendResponse(
+            [&](Ice::OutputStream* ostr)
+            {
+                ostr->writeAll(ret);
+            });
+    };
+    try
+    {
+        this->getMapMetricsFailuresAsync(std::move(iceP_view), std::move(iceP_map), std::move(responseCb), [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
     {
-        IceInternal::Ex::throwUOE(ConnectionMetrics::ice_staticId(), v);
+        responseHandler->sendException(std::current_exception());
     }
 }
-/// \endcond
 
-namespace Ice
-{
+void
+IceMX::AsyncMetricsAdmin::_iceD_getMetricsFailures(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse)
+{
+    checkNonIdempotent(request.current());
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    std::string iceP_view;
+    std::string iceP_map;
+    std::string iceP_id;
+    istr->readAll(iceP_view, iceP_map, iceP_id);
+    istr->endEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    auto responseCb = [responseHandler](const MetricsFailures& ret)
+    {
+        responseHandler->sendResponse(
+            [&](Ice::OutputStream* ostr)
+            {
+                ostr->writeAll(ret);
+            });
+    };
+    try
+    {
+        this->getMetricsFailuresAsync(std::move(iceP_view), std::move(iceP_map), std::move(iceP_id), std::move(responseCb), [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
+    }
 }
 
-#endif
+const char*
+IceMX::AsyncMetricsAdmin::ice_staticId() noexcept
+{
+    return "::IceMX::MetricsAdmin";
+}